diff --git a/kdevplatform/debugger/variable/variablecollection.cpp b/kdevplatform/debugger/variable/variablecollection.cpp
index cac4508c48..70cf1aad81 100644
--- a/kdevplatform/debugger/variable/variablecollection.cpp
+++ b/kdevplatform/debugger/variable/variablecollection.cpp
@@ -1,553 +1,553 @@
 /*
  * KDevelop Debugger Support
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2008 Vladimir Prus <ghost@cs.msu.su>
  * Copyright 2009 Niko Sams <niko.sams@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "variablecollection.h"
 
 #include <QFont>
 #include <QApplication>
 
 #include <KColorScheme>
 #include <KLocalizedString>
 #include <KTextEditor/TextHintInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include "../../interfaces/icore.h"
 #include "../../interfaces/idocumentcontroller.h"
 #include "../../interfaces/iuicontroller.h"
 #include "../../sublime/controller.h"
 #include "../../sublime/view.h"
 #include "../../interfaces/idebugcontroller.h"
 #include "../interfaces/idebugsession.h"
 #include "../interfaces/ivariablecontroller.h"
 #include <debug.h>
 #include "util/texteditorhelpers.h"
 #include "variabletooltip.h"
 #include <sublime/area.h>
 
 namespace KDevelop {
 
 IDebugSession* currentSession()
 {
     return ICore::self()->debugController()->currentSession();
 }
 
 IDebugSession::DebuggerState currentSessionState()
 {
     if (!currentSession()) return IDebugSession::NotStartedState;
     return currentSession()->state();
 }
 
 bool hasStartedSession()
 {
     IDebugSession::DebuggerState s = currentSessionState();
     return s != IDebugSession::NotStartedState && s != IDebugSession::EndedState;
 }
 
 Variable::Variable(TreeModel* model, TreeItem* parent,
                    const QString& expression,
                    const QString& display)
   : TreeItem(model, parent)
   , m_expression(expression)
   , m_inScope(true)
   , m_topLevel(true)
   , m_changed(false)
   , m_showError(false)
   , m_format(Natural)
 {
     // FIXME: should not duplicate the data, instead overload 'data'
     // and return expression_ directly.
     if (display.isEmpty())
         setData(QVector<QVariant>{expression, QString(), QString()});
     else
         setData(QVector<QVariant>{display, QString(), QString()});
 }
 
 QString Variable::expression() const
 {
     return m_expression;
 }
 
 bool Variable::inScope() const
 {
     return m_inScope;
 }
 
 void Variable::setValue(const QString& v)
 {
     itemData[VariableCollection::ValueColumn] = v;
     reportChange();
 }
 
 QString Variable::value() const
 {
     return itemData[VariableCollection::ValueColumn].toString();
 }
 
 void Variable::setType(const QString& type)
 {
     itemData[VariableCollection::TypeColumn] = type;
     reportChange();
 }
 
 QString Variable::type() const
 {
     return itemData[VariableCollection::TypeColumn].toString();
 }
 
 void Variable::setTopLevel(bool v)
 {
     m_topLevel = v;
 }
 
 void Variable::setInScope(bool v)
 {
     m_inScope = v;
     for (int i=0; i < childCount(); ++i) {
         if (Variable *var = qobject_cast<Variable*>(child(i))) {
             var->setInScope(v);
         }
     }
     reportChange();
 }
 
 void Variable::setShowError (bool v)
 {
     m_showError = v;
     reportChange();
 }
 
 bool Variable::showError()
 {
     return m_showError;
 }
 
 
 Variable::~Variable()
 {
 }
 
 void Variable::die()
 {
     removeSelf();
     deleteLater();
 }
 
 
 void Variable::setChanged(bool c)
 {
     m_changed=c;
     reportChange();
 }
 
 void Variable::resetChanged()
 {
     setChanged(false);
     for (int i=0; i<childCount(); ++i) {
         TreeItem* childItem = child(i);
         if (qobject_cast<Variable*>(childItem)) {
             static_cast<Variable*>(childItem)->resetChanged();
         }
     }
 }
 
 Variable::format_t Variable::str2format(const QString& str)
 {
     if(str==QLatin1String("Binary") || str==QLatin1String("binary"))          return Binary;
     if(str==QLatin1String("Octal") || str==QLatin1String("octal"))            return Octal;
     if(str==QLatin1String("Decimal") || str==QLatin1String("decimal"))        return Decimal;
     if(str==QLatin1String("Hexadecimal") || str==QLatin1String("hexadecimal"))return Hexadecimal;
 
     return Natural; // maybe most reasonable default
 }
 
 QString Variable::format2str(format_t format)
 {
     switch(format) {
         case Natural:       return QStringLiteral("natural");
         case Binary:        return QStringLiteral("binary");
         case Octal:         return QStringLiteral("octal");
         case Decimal:       return QStringLiteral("decimal");
         case Hexadecimal:   return QStringLiteral("hexadecimal");
     }
     return QString();
 }
 
 
 void Variable::setFormat(Variable::format_t format)
 {
     if (m_format != format) {
         m_format = format;
         formatChanged();
     }
 }
 
 void Variable::formatChanged()
 {
 }
 
 bool Variable::isPotentialProblematicValue() const
 {
     const auto value = data(VariableCollection::ValueColumn, Qt::DisplayRole).toString();
     return value == QLatin1String("0x0");
 }
 
 QVariant Variable::data(int column, int role) const
 {
     if (m_showError) {
         if (role == Qt::FontRole) {
             QVariant ret = TreeItem::data(column, role);
             QFont font = ret.value<QFont>();
             font.setStyle(QFont::StyleItalic);
             return font;
         } else if (column == 1 && role == Qt::DisplayRole) {
             return i18n("Error");
         }
     }
     if (column == 1 && role == Qt::TextColorRole)
     {
         KColorScheme scheme(QPalette::Active);
         if (!m_inScope) {
             return scheme.foreground(KColorScheme::InactiveText).color();
         } else if (isPotentialProblematicValue()) {
             return scheme.foreground(KColorScheme::NegativeText).color();
         } else if (m_changed) {
             return scheme.foreground(KColorScheme::NeutralText).color();
         }
     }
     if (role == Qt::ToolTipRole) {
         return TreeItem::data(column, Qt::DisplayRole);
     }
 
     return TreeItem::data(column, role);
 }
 
 Watches::Watches(TreeModel* model, TreeItem* parent)
 : TreeItem(model, parent), finishResult_(nullptr)
 {
     setData(QVector<QVariant>{i18n("Auto"), QString()});
 }
 
 Variable* Watches::add(const QString& expression)
 {
     if (!hasStartedSession()) return nullptr;
 
     Variable* v = currentSession()->variableController()->createVariable(
         model(), this, expression);
     appendChild(v);
     v->attachMaybe();
     if (childCount() == 1 && !isExpanded()) {
         setExpanded(true);
     }
     return v;
 }
 
 Variable *Watches::addFinishResult(const QString& convenienceVarible)
 {
     if( finishResult_ )
     {
         removeFinishResult();
     }
     finishResult_ = currentSession()->variableController()->createVariable(
         model(), this, convenienceVarible, QStringLiteral("$ret"));
     appendChild(finishResult_);
     finishResult_->attachMaybe();
     if (childCount() == 1 && !isExpanded()) {
         setExpanded(true);
     }
     return finishResult_;
 }
 
 void Watches::removeFinishResult()
 {
     if (finishResult_)
     {
         finishResult_->die();
         finishResult_ = nullptr;
     }
 }
 
 void Watches::resetChanged()
 {
     for (int i=0; i<childCount(); ++i) {
         TreeItem* childItem = child(i);
         if (qobject_cast<Variable*>(childItem)) {
             static_cast<Variable*>(childItem)->resetChanged();
         }
     }
 }
 
 QVariant Watches::data(int column, int role) const
 {
 #if 0
     if (column == 0 && role == Qt::FontRole)
     {
         /* FIXME: is creating font again and agian efficient? */
         QFont f = font();
         f.setBold(true);
         return f;
     }
 #endif
     return TreeItem::data(column, role);
 }
 
 void Watches::reinstall()
 {
     for (int i = 0; i < childItems.size(); ++i)
     {
         Variable* v = static_cast<Variable*>(child(i));
         v->attachMaybe();
     }
 }
 
 Locals::Locals(TreeModel* model, TreeItem* parent, const QString &name)
 : TreeItem(model, parent)
 {
     setData(QVector<QVariant>{name, QString()});
 }
 
 QList<Variable*> Locals::updateLocals(const QStringList& locals)
 {
     QSet<QString> existing, current;
     for (int i = 0; i < childItems.size(); i++)
     {
         Q_ASSERT(qobject_cast<KDevelop::Variable*>(child(i)));
         Variable* var= static_cast<KDevelop::Variable*>(child(i));
         existing << var->expression();
     }
 
     foreach (const QString& var, locals) {
         current << var;
         // If we currently don't display this local var, add it.
         if( !existing.contains( var ) ) {
             // FIXME: passing variableCollection this way is awkward.
             // In future, variableCollection probably should get a
             // method to create variable.
             Variable* v =
                 currentSession()->variableController()->createVariable(
                     ICore::self()->debugController()->variableCollection(),
                     this, var );
             appendChild( v, false );
         }
     }
 
     for (int i = 0; i < childItems.size(); ++i) {
         KDevelop::Variable* v = static_cast<KDevelop::Variable*>(child(i));
         if (!current.contains(v->expression())) {
             removeChild(i);
             --i;
             // FIXME: check that -var-delete is sent.
             delete v;
         }
     }
 
 
     if (hasMore()) {
         setHasMore(false);
     }
 
     // Variables which changed just value are updated by a call to -var-update.
     // Variables that changed type -- likewise.
 
     QList<Variable*> ret;
     ret.reserve(childItems.size());
     foreach (TreeItem *i, childItems) {
         Q_ASSERT(qobject_cast<Variable*>(i));
         ret << static_cast<Variable*>(i);
     }
     return ret;
 }
 
 void Locals::resetChanged()
 {
     for (int i=0; i<childCount(); ++i) {
         TreeItem* childItem = child(i);
         if (qobject_cast<Variable*>(childItem)) {
             static_cast<Variable*>(childItem)->resetChanged();
         }
     }
 }
 
 VariablesRoot::VariablesRoot(TreeModel* model)
     : TreeItem(model)
     , m_watches(new Watches(model, this))
 {
     appendChild(m_watches, true);
 }
 
 
 Locals* VariablesRoot::locals(const QString& name)
 {
     if (!m_locals.contains(name)) {
         m_locals[name] = new Locals(model(), this, name);
         appendChild(m_locals[name]);
     }
     return m_locals[name];
 }
 
 QHash<QString, Locals*> VariablesRoot::allLocals() const
 {
     return m_locals;
 }
 
 void VariablesRoot::resetChanged()
 {
     m_watches->resetChanged();
     foreach (Locals *l, m_locals) {
         l->resetChanged();
     }
 }
 
 VariableCollection::VariableCollection(IDebugController* controller)
     : TreeModel({i18n("Name"), i18n("Value"), i18n("Type")}, controller)
     , m_widgetVisible(false)
     , m_textHintProvider(this)
 {
     m_universe = new VariablesRoot(this);
     setRootItem(m_universe);
 
     //new ModelTest(this);
 
     connect (ICore::self()->documentController(),
          &IDocumentController::textDocumentCreated,
          this,
          &VariableCollection::textDocumentCreated );
 
     connect(controller, &IDebugController::currentSessionChanged,
              this, &VariableCollection::updateAutoUpdate);
 
     // Qt5 signal slot syntax does not support default arguments
     auto callUpdateAutoUpdate = [&] { updateAutoUpdate(); };
 
     connect(locals(), &Locals::expanded, this, callUpdateAutoUpdate);
     connect(locals(), &Locals::collapsed, this, callUpdateAutoUpdate);
     connect(watches(), &Watches::expanded, this, callUpdateAutoUpdate);
     connect(watches(), &Watches::collapsed, this, callUpdateAutoUpdate);
 }
 
 void VariableCollection::variableWidgetHidden()
 {
     m_widgetVisible = false;
     updateAutoUpdate();
 }
 
 void VariableCollection::variableWidgetShown()
 {
     m_widgetVisible = true;
     updateAutoUpdate();
 }
 
 void VariableCollection::updateAutoUpdate(IDebugSession* session)
 {
     if (!session) session = currentSession();
     qCDebug(DEBUGGER) << session;
     if (!session) return;
 
     if (!m_widgetVisible) {
         session->variableController()->setAutoUpdate(IVariableController::UpdateNone);
     } else {
         QFlags<IVariableController::UpdateType> t = IVariableController::UpdateNone;
         if (locals()->isExpanded()) t |= IVariableController::UpdateLocals;
         if (watches()->isExpanded()) t |= IVariableController::UpdateWatches;
         session->variableController()->setAutoUpdate(t);
     }
 }
 
 VariableCollection::~ VariableCollection()
 {
 }
 
 void VariableCollection::textDocumentCreated(IDocument* doc)
 {
   connect( doc->textDocument(),
        &KTextEditor::Document::viewCreated,
        this, &VariableCollection::viewCreated );
 
   foreach( KTextEditor::View* view, doc->textDocument()->views() )
     viewCreated( doc->textDocument(), view );
 }
 
 void VariableCollection::viewCreated(KTextEditor::Document* doc,
                                      KTextEditor::View* view)
 {
     Q_UNUSED(doc);
     using namespace KTextEditor;
     TextHintInterface *iface = dynamic_cast<TextHintInterface*>(view);
     if( !iface )
         return;
 
     iface->registerTextHintProvider(&m_textHintProvider);
 }
 
 Locals* VariableCollection::locals(const QString &name) const
 {
     return m_universe->locals(name.isEmpty() ? i18n("Locals") : name);
 }
 
 VariableProvider::VariableProvider(VariableCollection* collection)
     : KTextEditor::TextHintProvider()
     , m_collection(collection)
 {
 }
 
 QString VariableProvider::textHint(KTextEditor::View* view, const KTextEditor::Cursor& cursor)
 {
     if (!hasStartedSession())
         return QString();
 
     if (ICore::self()->uiController()->activeArea()->objectName() != QLatin1String("debug"))
         return QString();
 
     //TODO: These keyboardModifiers should also hide already opened tooltip, and show another one for code area.
     if (QApplication::keyboardModifiers() == Qt::ControlModifier ||
         QApplication::keyboardModifiers() == Qt::AltModifier){
         return QString();
     }
 
     KTextEditor::Document* doc = view->document();
 
     KTextEditor::Range expressionRange = currentSession()->variableController()->expressionRangeUnderCursor(doc, cursor);
 
     if (!expressionRange.isValid())
         return QString();
     QString expression = doc->text(expressionRange).trimmed();
 
     // Don't do anything if there's already an open tooltip with matching range
     if (m_collection->m_activeTooltip && m_collection->m_activeTooltip->variable()->expression() == expression)
         return QString();
     if (expression.isEmpty())
         return QString();
 
     QPoint local = view->cursorToCoordinate(cursor);
     QPoint global = view->mapToGlobal(local);
     QWidget* w = view->childAt(local);
     if (!w)
         w = view;
 
     m_collection->m_activeTooltip = new VariableToolTip(w, global+QPoint(30,30), expression);
-    m_collection->m_activeTooltip->setHandleRect(KTextEditorHelpers::getItemBoundingRect(view, expressionRange));
+    m_collection->m_activeTooltip->setHandleRect(KTextEditorHelpers::itemBoundingRect(view, expressionRange));
     return QString();
 }
 
 }
 
diff --git a/kdevplatform/language/classmodel/classmodel.cpp b/kdevplatform/language/classmodel/classmodel.cpp
index 32614afe1f..196b493ae5 100644
--- a/kdevplatform/language/classmodel/classmodel.cpp
+++ b/kdevplatform/language/classmodel/classmodel.cpp
@@ -1,282 +1,282 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2007-2008 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "classmodel.h"
 #include "classmodelnode.h"
 #include "allclassesfolder.h"
 #include "projectfolder.h"
 #include "../duchain/declaration.h"
 #include <typeinfo>
 
 #include "../../interfaces/icore.h"
 #include "../../interfaces/iproject.h"
 #include "../../interfaces/iprojectcontroller.h"
 
 using namespace KDevelop;
 using namespace ClassModelNodes;
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 NodesModelInterface::~NodesModelInterface()
 {
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 ClassModel::ClassModel()
   : m_features(NodesModelInterface::AllProjectsClasses |
                NodesModelInterface::BaseAndDerivedClasses |
                NodesModelInterface::ClassInternals)
 {
   m_topNode = new FolderNode(QStringLiteral("Top Node"), this);
 
   if ( features().testFlag(NodesModelInterface::AllProjectsClasses) )
   {
     m_allClassesNode = new FilteredAllClassesFolder(this);
     m_topNode->addNode( m_allClassesNode );
   }
 
   connect(ICore::self()->projectController(), &IProjectController::projectClosing,
           this, &ClassModel::removeProjectNode);
   connect(ICore::self()->projectController(), &IProjectController::projectOpened,
           this, &ClassModel::addProjectNode);
 
   foreach ( IProject* project, ICore::self()->projectController()->projects() ) {
     addProjectNode(project);
   }
 }
 
 ClassModel::~ClassModel()
 {
   delete m_topNode;
 }
 
 void ClassModel::updateFilterString(const QString& a_newFilterString)
 {
   m_allClassesNode->updateFilterString(a_newFilterString);
   foreach ( ClassModelNodes::FilteredProjectFolder* folder, m_projectNodes ) {
     folder->updateFilterString(a_newFilterString);
   }
 }
 
 
 void ClassModel::collapsed(const QModelIndex& index)
 {
   Node* node = static_cast<Node*>(index.internalPointer());
 
   node->collapse();
 }
 
 void ClassModel::expanded(const QModelIndex& index)
 {
   Node* node = static_cast<Node*>(index.internalPointer());
 
   node->expand();
 }
 
 QFlags< Qt::ItemFlag > ClassModel::flags(const QModelIndex&) const
 {
   return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 }
 
 int ClassModel::rowCount(const QModelIndex& parent) const
 {
   Node* node = m_topNode;
 
   if ( parent.isValid() )
     node = static_cast<Node*>(parent.internalPointer());
 
-  return node->getChildren().size();
+  return node->children().size();
 }
 
 QVariant ClassModel::data(const QModelIndex& index, int role) const
 {
   if ( !index.isValid() )
     return QVariant();
 
   Node* node = static_cast<Node*>(index.internalPointer());
 
   if ( role == Qt::DisplayRole )
     return node->displayName();
 
   if ( role == Qt::DecorationRole )
   {
-    QIcon icon = node->getCachedIcon();
+    QIcon icon = node->cachedIcon();
     return icon.isNull() ? QVariant() : icon;
   }
 
   return QVariant();
 }
     
 QVariant ClassModel::headerData(int, Qt::Orientation, int role) const
 {
   if ( role == Qt::DisplayRole )
     return QStringLiteral("Class");
 
   return QVariant();
 }
 
 int ClassModel::columnCount(const QModelIndex&) const
 {
   return 1;
 }
 
 bool ClassModel::hasChildren(const QModelIndex& parent) const
 {
   if ( !parent.isValid() )
     return true;
 
   Node* node = static_cast<Node*>(parent.internalPointer());
 
   return node->hasChildren();
 }
 
 QModelIndex ClassModel::index(int row, int column, const QModelIndex& parent) const
 {  
   if (row < 0 || column != 0)
     return QModelIndex();
 
   Node* node = m_topNode; 
   if ( parent.isValid() )
     node = static_cast<Node*>(parent.internalPointer());
 
-  if ( row >= node->getChildren().size() )
+  if ( row >= node->children().size() )
     return QModelIndex();
 
-  return index(node->getChildren()[row]);
+  return index(node->children()[row]);
 }
 
 QModelIndex ClassModel::parent(const QModelIndex& childIndex) const
 {
   if ( !childIndex.isValid() )
     return QModelIndex();
 
   Node* childNode = static_cast<Node*>(childIndex.internalPointer());
 
-  if ( childNode->getParent() == m_topNode )
+  if ( childNode->parent() == m_topNode )
     return QModelIndex();
 
-  return index( childNode->getParent() );
+  return index( childNode->parent() );
 }
 
 QModelIndex ClassModel::index(ClassModelNodes::Node* a_node) const
 {
   if (!a_node) {
     return QModelIndex();
   }
 
   // If no parent exists, we have an invalid index (root node or not part of a model).
-  if ( a_node->getParent() == nullptr )
+  if ( a_node->parent() == nullptr )
     return QModelIndex();
 
   return createIndex(a_node->row(), 0, a_node);
 }
 
 KDevelop::DUChainBase* ClassModel::duObjectForIndex(const QModelIndex& a_index)
 {
   if ( !a_index.isValid() )
     return nullptr;
     
   Node* node = static_cast<Node*>(a_index.internalPointer());
 
   if ( IdentifierNode* identifierNode = dynamic_cast<IdentifierNode*>(node) )
-    return identifierNode->getDeclaration();
+    return identifierNode->declaration();
 
   // Non was found.
   return nullptr;
 }
 
-QModelIndex ClassModel::getIndexForIdentifier(const KDevelop::IndexedQualifiedIdentifier& a_id)
+QModelIndex ClassModel::indexForIdentifier(const KDevelop::IndexedQualifiedIdentifier& a_id)
 {
   ClassNode* node = m_allClassesNode->findClassNode(a_id);
   if ( node == nullptr )
     return QModelIndex();
 
   return index(node);
 }
 
 
 void ClassModel::nodesLayoutAboutToBeChanged(ClassModelNodes::Node*)
 {
   emit layoutAboutToBeChanged();
 }
 
 void ClassModel::nodesLayoutChanged(ClassModelNodes::Node*)
 {
   const QModelIndexList oldIndexList = persistentIndexList();
   QModelIndexList newIndexList;
 
   newIndexList.reserve(oldIndexList.size());
   for (const QModelIndex& oldIndex : oldIndexList) {
     Node* node = static_cast<Node*>(oldIndex.internalPointer());
     if ( node )
     {
       // Re-map the index.
       newIndexList << createIndex(node->row(), 0, node);
     }
     else
       newIndexList << oldIndex;
   }
 
   changePersistentIndexList(oldIndexList, newIndexList);
 
   emit layoutChanged();
 }
 
 void ClassModel::nodesAboutToBeRemoved(ClassModelNodes::Node* a_parent, int a_first, int a_last)
 {
   beginRemoveRows(index(a_parent), a_first, a_last);
 }
 
 void ClassModel::nodesRemoved(ClassModelNodes::Node*)
 {
   endRemoveRows();
 }
 
 void ClassModel::nodesAboutToBeAdded(ClassModelNodes::Node* a_parent, int a_pos, int a_size)
 {
   beginInsertRows(index(a_parent), a_pos, a_pos + a_size - 1);
 }
 
 void ClassModel::nodesAdded(ClassModelNodes::Node*)
 {
   endInsertRows();
 }
 
 void ClassModel::addProjectNode( IProject* project )
 {
   m_projectNodes[project] = new ClassModelNodes::FilteredProjectFolder(this, project);
   nodesLayoutAboutToBeChanged(m_projectNodes[project]);
   m_topNode->addNode(m_projectNodes[project]);
   nodesLayoutChanged(m_projectNodes[project]);
 }
 
 void ClassModel::removeProjectNode( IProject* project )
 {
   m_topNode->removeNode(m_projectNodes[project]);
   m_projectNodes.remove(project);
 }
 
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
diff --git a/kdevplatform/language/classmodel/classmodel.h b/kdevplatform/language/classmodel/classmodel.h
index 6c92cf4fad..c8e0dca2dc 100644
--- a/kdevplatform/language/classmodel/classmodel.h
+++ b/kdevplatform/language/classmodel/classmodel.h
@@ -1,155 +1,155 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2007-2008 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_CLASSMODEL_H
 #define KDEVPLATFORM_CLASSMODEL_H
 
 #include <QAbstractItemModel>
 #include "classmodelnode.h"
 
 #include <language/languageexport.h>
 
 class ClassBrowserPlugin;
 
 namespace KDevelop
 {
   class TopDUContext;
   class IDocument;
   class DUContext;
   class IProject;
   class DUChainBase;
   class IndexedQualifiedIdentifier;
 }
 
 namespace ClassModelNodes
 {
   class Node;
   class FilteredAllClassesFolder;
   class FilteredProjectFolder;
   class FolderNode;
   class IdentifierNode;
 }
 
 /// The model interface accessible from the nodes.
 class NodesModelInterface
 {
 public:
   virtual ~NodesModelInterface();
 
 public:
   enum Feature {
       AllProjectsClasses = 0x1,
       BaseAndDerivedClasses = 0x2,
       ClassInternals = 0x4
   };
   Q_DECLARE_FLAGS(Features, Feature)
 
   virtual void nodesLayoutAboutToBeChanged(ClassModelNodes::Node* a_parent) = 0;
   virtual void nodesLayoutChanged(ClassModelNodes::Node* a_parent) = 0;
   virtual void nodesAboutToBeRemoved(ClassModelNodes::Node* a_parent, int a_first, int a_last) = 0;
   virtual void nodesRemoved(ClassModelNodes::Node* a_parent) = 0;
   virtual void nodesAboutToBeAdded(ClassModelNodes::Node* a_parent, int a_pos, int a_size) = 0;
   virtual void nodesAdded(ClassModelNodes::Node* a_parent) = 0;
   virtual Features features() const = 0;
 };
 
 /**
  * @short A model that holds a convinient representation of the defined class in the project
  * 
  * This model doesn't have much code in it, it mostly acts as a glue between the different
  * nodes and the tree view.
  *
  * The nodes are defined in the namespace @ref ClassModelNodes
  */
 class KDEVPLATFORMLANGUAGE_EXPORT ClassModel : public QAbstractItemModel, public NodesModelInterface
 {
   Q_OBJECT
 public:
   ClassModel();
   ~ClassModel() override;
 
 public:
   /// Retrieve the DU object related to the specified index.
   /// @note DUCHAINS READER LOCK MUST BE TAKEN!
   KDevelop::DUChainBase* duObjectForIndex(const QModelIndex& a_index);
 
   /// Call this to retrieve the index for the node associated with the specified id.
-  QModelIndex getIndexForIdentifier(const KDevelop::IndexedQualifiedIdentifier& a_id);
+  QModelIndex indexForIdentifier(const KDevelop::IndexedQualifiedIdentifier& a_id);
 
   /// Return the model index associated with the given node.
   QModelIndex index(ClassModelNodes::Node* a_node) const;
 
   inline void setFeatures(NodesModelInterface::Features features);
   inline NodesModelInterface::Features features() const override { return m_features; }
 
 public Q_SLOTS:
   /// Call this to update the filter string for the search results folder.
   void updateFilterString(const QString& a_newFilterString);
 
   /// removes the project-specific node
   void removeProjectNode(KDevelop::IProject* project);
   /// adds the project-specific node
   void addProjectNode(KDevelop::IProject* project);
 
 private: // NodesModelInterface overrides
   void nodesLayoutAboutToBeChanged(ClassModelNodes::Node* a_parent) override;
   void nodesLayoutChanged(ClassModelNodes::Node* a_parent) override;
   void nodesAboutToBeRemoved(ClassModelNodes::Node* a_parent, int a_first, int a_last) override;
   void nodesRemoved(ClassModelNodes::Node* a_parent) override;
   void nodesAboutToBeAdded(ClassModelNodes::Node* a_parent, int a_pos, int a_size) override;
   void nodesAdded(ClassModelNodes::Node* a_parent) override;
 
 private:
   /// Main level node - it's usually invisible.
   ClassModelNodes::Node* m_topNode;
   ClassModelNodes::FilteredAllClassesFolder* m_allClassesNode;
   QMap<KDevelop::IProject*, ClassModelNodes::FilteredProjectFolder*> m_projectNodes;
   NodesModelInterface::Features m_features;
 
 public Q_SLOTS:
   /// This slot needs to be attached to collapsed signal in the tree view.
   void collapsed(const QModelIndex& index);
   /// This slot needs to be attached to expanded signal in the tree view.
   void expanded(const QModelIndex& index);
 
 public: // QAbstractItemModel overrides
   QFlags< Qt::ItemFlag > flags(const QModelIndex&) const override;
   QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
   QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
   int rowCount(const QModelIndex& parent = QModelIndex()) const override;
   int columnCount(const QModelIndex& parent = QModelIndex()) const override;
 
   bool hasChildren(const QModelIndex& parent = QModelIndex()) const override;
 
   QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override;
   QModelIndex parent(const QModelIndex& child) const override;
 };
 
 inline void ClassModel::setFeatures(Features features)
 { m_features = features; }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(NodesModelInterface::Features)
 
 #endif
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
 
diff --git a/kdevplatform/language/classmodel/classmodelnode.cpp b/kdevplatform/language/classmodel/classmodelnode.cpp
index 00655fdb66..4a97745bfd 100644
--- a/kdevplatform/language/classmodel/classmodelnode.cpp
+++ b/kdevplatform/language/classmodel/classmodelnode.cpp
@@ -1,613 +1,613 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2007-2009 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "classmodelnode.h"
 
 #include <typeinfo>
 #include <KLocalizedString>
 
 #include "../duchain/duchainlock.h"
 #include "../duchain/duchain.h"
 #include "../duchain/persistentsymboltable.h"
 #include "../duchain/duchainutils.h"
 #include "../duchain/classdeclaration.h"
 #include "../duchain/classfunctiondeclaration.h"
 #include "../duchain/types/functiontype.h"
 #include "../duchain/types/enumerationtype.h"
 
 #include <debug.h>
 
 using namespace KDevelop;
 using namespace ClassModelNodes;
 
 IdentifierNode::IdentifierNode(KDevelop::Declaration* a_decl,
                                NodesModelInterface* a_model,
                                const QString& a_displayName)
   : DynamicNode(a_displayName.isEmpty() ? a_decl->identifier().toString() : a_displayName, a_model)
   , m_identifier(a_decl->qualifiedIdentifier())
   , m_indexedDeclaration(a_decl)
   , m_cachedDeclaration(a_decl)
 {
 }
 
-Declaration* IdentifierNode::getDeclaration()
+Declaration* IdentifierNode::declaration()
 {
   if ( !m_cachedDeclaration )
     m_cachedDeclaration = m_indexedDeclaration.declaration();
 
   return m_cachedDeclaration.data();
 }
 
 bool IdentifierNode::getIcon(QIcon& a_resultIcon)
 {
   DUChainReadLocker readLock(DUChain::lock());
 
-  Declaration* decl = getDeclaration();
+  Declaration* decl = declaration();
   if ( decl )
     a_resultIcon = DUChainUtils::iconForDeclaration(decl);
 
   return !a_resultIcon.isNull();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 EnumNode::EnumNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model)
   : IdentifierNode(a_decl, a_model)
 {
   // Set display name for anonymous enums
   if ( m_displayName.isEmpty() )
     m_displayName = QStringLiteral("*Anonymous*");
 }
 
 bool EnumNode::getIcon(QIcon& a_resultIcon)
 {
   DUChainReadLocker readLock(DUChain::lock());
 
-  ClassMemberDeclaration* decl = dynamic_cast<ClassMemberDeclaration*>(getDeclaration());
+  ClassMemberDeclaration* decl = dynamic_cast<ClassMemberDeclaration*>(declaration());
   if ( decl == nullptr )
   {
     static QIcon Icon = QIcon::fromTheme(QStringLiteral("enum"));
     a_resultIcon = Icon;
   }
   else
   {
     if ( decl->accessPolicy() == Declaration::Protected )
     {
       static QIcon Icon = QIcon::fromTheme(QStringLiteral("protected_enum"));
       a_resultIcon = Icon;
     }
     else if ( decl->accessPolicy() == Declaration::Private )
     {
       static QIcon Icon = QIcon::fromTheme(QStringLiteral("private_enum"));
       a_resultIcon = Icon;
     }
     else
     {
       static QIcon Icon = QIcon::fromTheme(QStringLiteral("enum"));
       a_resultIcon = Icon;
     }
   }
 
   return true;
 }
 
 void EnumNode::populateNode()
 {
   DUChainReadLocker readLock(DUChain::lock());
 
-  Declaration* decl = getDeclaration();
+  Declaration* decl = declaration();
 
   if ( decl->internalContext() )
     foreach( Declaration* enumDecl, decl->internalContext()->localDeclarations() )
       addNode( new EnumNode(enumDecl, m_model) );
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 ClassNode::ClassNode(Declaration* a_decl, NodesModelInterface* a_model)
   : IdentifierNode(a_decl, a_model)
 {
 }
 
 ClassNode::~ClassNode()
 {
   if ( !m_cachedUrl.isEmpty() )
   {
     ClassModelNodesController::self().unregisterForChanges(m_cachedUrl, this);
     m_cachedUrl = IndexedString();
   }
 }
 
 void ClassNode::populateNode()
 {
   DUChainReadLocker readLock(DUChain::lock());
 
   if ( m_model->features().testFlag(NodesModelInterface::ClassInternals) )
   {
     if ( updateClassDeclarations() )
     {
-      m_cachedUrl = getDeclaration()->url();
+      m_cachedUrl = declaration()->url();
       ClassModelNodesController::self().registerForChanges(m_cachedUrl, this);
     }
   }
 
   // Add special folders
   if (m_model->features().testFlag(NodesModelInterface::BaseAndDerivedClasses))
     addBaseAndDerived();
 }
 
 template <> inline bool qMapLessThanKey(const IndexedIdentifier &key1, const IndexedIdentifier &key2)
 {
-  return key1.getIndex() < key2.getIndex();
+  return key1.index() < key2.index();
 }
 
 bool ClassNode::updateClassDeclarations()
 {
   bool hadChanges = false;
   SubIdentifiersMap existingIdentifiers = m_subIdentifiers;
 
-  ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>(getDeclaration());
+  ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>(declaration());
 
   if ( klass )
   {
     foreach(Declaration* decl, klass->internalContext()->localDeclarations())
     {
       // Ignore forward declarations.
       if ( decl->isForwardDeclaration() )
         continue;
 
       // Don't add existing declarations.
       if ( existingIdentifiers.contains( decl->ownIndex() ) )
       {
         existingIdentifiers.remove(decl->ownIndex());
         continue;
       }
 
       Node* newNode = nullptr;
 
       if ( EnumerationType::Ptr enumType = decl->type<EnumerationType>() )
         newNode = new EnumNode( decl, m_model );
       else if ( decl->isFunctionDeclaration() )
         newNode = new FunctionNode( decl, m_model );
       else if ( ClassDeclaration* classDecl = dynamic_cast<ClassDeclaration*>(decl) )
         newNode = new ClassNode(classDecl, m_model);
       else if ( ClassMemberDeclaration* memDecl = dynamic_cast<ClassMemberDeclaration*>(decl) )
         newNode = new ClassMemberNode( memDecl, m_model );
       else
       {
         // Debug - for reference.
         qCDebug(LANGUAGE) << "class: " << klass->toString() << "name: " << decl->toString() << " - unknown declaration type: " << typeid(*decl).name();
       }
 
       if ( newNode )
       {
         addNode(newNode);
 
         // Also remember the identifier.
         m_subIdentifiers.insert(decl->ownIndex(), newNode);
 
         hadChanges = true;
       }
     }
   }
 
   // Remove old existing identifiers
   for ( SubIdentifiersMap::iterator iter = existingIdentifiers.begin();
         iter != existingIdentifiers.end();
         ++iter )
   {
     iter.value()->removeSelf();
     m_subIdentifiers.remove(iter.key());
     hadChanges = true;
   }
 
   return hadChanges;
 }
 
 bool ClassNode::addBaseAndDerived()
 {
   bool added = false;
 
   BaseClassesFolderNode *baseClassesNode = new BaseClassesFolderNode( m_model );
   addNode( baseClassesNode );
   if ( !baseClassesNode->hasChildren() )
     removeNode( baseClassesNode );
   else
     added = true;
 
   DerivedClassesFolderNode *derivedClassesNode = new DerivedClassesFolderNode( m_model );
   addNode( derivedClassesNode );
   if ( !derivedClassesNode->hasChildren() )
     removeNode( derivedClassesNode );
   else
     added = true;
 
   return added;
 }
 
 void ClassNode::nodeCleared()
 {
   if ( !m_cachedUrl.isEmpty() )
   {
     ClassModelNodesController::self().unregisterForChanges(m_cachedUrl, this);
     m_cachedUrl = IndexedString();
   }
 
   m_subIdentifiers.clear();
 }
 
 void ClassModelNodes::ClassNode::documentChanged(const KDevelop::IndexedString&)
 {
   DUChainReadLocker readLock(DUChain::lock());
 
   if ( updateClassDeclarations() )
     recursiveSort();
 }
 
 ClassNode* ClassNode::findSubClass(const KDevelop::IndexedQualifiedIdentifier& a_id)
 {
   // Make sure we have sub nodes.
   performPopulateNode();
 
   /// @todo This is slow - we go over all the sub identifiers but the assumption is that
   ///       this function call is rare and the list is not that long.
   foreach(Node* item, m_subIdentifiers)
   {
     ClassNode* classNode = dynamic_cast<ClassNode*>(item);
     if ( classNode == nullptr )
       continue;
 
-    if ( classNode->getIdentifier() == a_id )
+    if ( classNode->identifier() == a_id )
       return classNode;
   }
 
   return nullptr;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 FunctionNode::FunctionNode(Declaration* a_decl, NodesModelInterface* a_model)
   : IdentifierNode(a_decl, a_model)
 {
   // Append the argument signature to the identifier's name (which is what the displayName is.
   if (FunctionType::Ptr type = a_decl->type<FunctionType>())
     m_displayName += type->partToString(FunctionType::SignatureArguments);
 
   // Add special values for ctor / dtor to sort first
   ClassFunctionDeclaration* classmember = dynamic_cast<ClassFunctionDeclaration*>(a_decl);
   if ( classmember ) {
     if ( classmember->isConstructor() || classmember->isDestructor() )
       m_sortableString = QLatin1Char('0') + m_displayName;
     else
       m_sortableString = QLatin1Char('1') + m_displayName;
   }
   else {
     m_sortableString = m_displayName;
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 ClassMemberNode::ClassMemberNode(KDevelop::ClassMemberDeclaration* a_decl, NodesModelInterface* a_model)
   : IdentifierNode(a_decl, a_model)
 {
 }
 
 bool ClassMemberNode::getIcon(QIcon& a_resultIcon)
 {
   DUChainReadLocker readLock(DUChain::lock());
 
-  ClassMemberDeclaration* decl = dynamic_cast<ClassMemberDeclaration*>(getDeclaration());
+  ClassMemberDeclaration* decl = dynamic_cast<ClassMemberDeclaration*>(declaration());
   if ( decl == nullptr )
     return false;
 
   if ( decl->isTypeAlias() )
   {
     static QIcon Icon = QIcon::fromTheme(QStringLiteral("typedef"));
     a_resultIcon = Icon;
   }
   else if ( decl->accessPolicy() == Declaration::Protected )
   {
     static QIcon Icon = QIcon::fromTheme(QStringLiteral("protected_field"));
     a_resultIcon = Icon;
   }
   else if ( decl->accessPolicy() == Declaration::Private )
   {
     static QIcon Icon = QIcon::fromTheme(QStringLiteral("private_field"));
     a_resultIcon = Icon;
   }
   else
   {
     static QIcon Icon = QIcon::fromTheme(QStringLiteral("field"));
     a_resultIcon = Icon;
   }
 
   return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 DynamicFolderNode::DynamicFolderNode(const QString& a_displayName, NodesModelInterface* a_model)
   : DynamicNode(a_displayName, a_model)
 {
 }
 
 bool DynamicFolderNode::getIcon(QIcon& a_resultIcon)
 {
   static QIcon folderIcon = QIcon::fromTheme(QStringLiteral("folder"));
   a_resultIcon = folderIcon;
   return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 FolderNode::FolderNode(const QString& a_displayName, NodesModelInterface* a_model)
   : Node(a_displayName, a_model)
 {
 }
 
 bool FolderNode::getIcon(QIcon& a_resultIcon)
 {
   static QIcon folderIcon = QIcon::fromTheme(QStringLiteral("folder"));
   a_resultIcon = folderIcon;
   return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 BaseClassesFolderNode::BaseClassesFolderNode(NodesModelInterface* a_model)
   : DynamicFolderNode(i18n("Base classes"), a_model)
 {
 
 }
 
 void BaseClassesFolderNode::populateNode()
 {
   DUChainReadLocker readLock(DUChain::lock());
 
-  ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>( static_cast<ClassNode*>(getParent())->getDeclaration() );
+  ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>( static_cast<ClassNode*>(parent())->declaration() );
   if ( klass )
   {
     // I use the imports instead of the baseClasses in the ClassDeclaration because I need
     // to get to the base class identifier which is not directly accessible through the
     // baseClasses function.
     foreach( const DUContext::Import& import, klass->internalContext()->importedParentContexts() )
     {
       DUContext* baseContext = import.context( klass->topContext() );
       if ( baseContext && baseContext->type() == DUContext::Class )
       {
         Declaration* baseClassDeclaration = baseContext->owner();
         if ( baseClassDeclaration )
         {
           // Add the base class.
           addNode( new ClassNode(baseClassDeclaration, m_model) );
         }
       }
     }
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 DerivedClassesFolderNode::DerivedClassesFolderNode(NodesModelInterface* a_model)
   : DynamicFolderNode(i18n("Derived classes"), a_model)
 {
 
 }
 
 void DerivedClassesFolderNode::populateNode()
 {
   DUChainReadLocker readLock(DUChain::lock());
 
-  ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>( static_cast<ClassNode*>(getParent())->getDeclaration() );
+  ClassDeclaration* klass = dynamic_cast<ClassDeclaration*>( static_cast<ClassNode*>(parent())->declaration() );
   if ( klass )
   {
     uint steps = 10000;
-    const QList<Declaration*> inheriters = DUChainUtils::getInheriters(klass, steps, true);
+    const QList<Declaration*> inheriters = DUChainUtils::inheriters(klass, steps, true);
 
     for (Declaration* decl : inheriters) {
       addNode( new ClassNode(decl, m_model) );
     }
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 Node::Node(const QString& a_displayName, NodesModelInterface* a_model)
   : m_parentNode(nullptr)
   , m_displayName(a_displayName)
   , m_model(a_model)
 {
 }
 
 Node::~Node()
 {
   // Notify the model about the removal of this nodes' children.
   if ( !m_children.empty() && m_model )
   {
     m_model->nodesAboutToBeRemoved(this, 0, m_children.size()-1);
     clear();
     m_model->nodesRemoved(this);
   }
 }
 
 
 void Node::clear()
 {
   qDeleteAll(m_children);
   m_children.clear();
 }
 
 void Node::addNode(Node* a_child)
 {
 /// @note This is disabled for performance reasons - we add them to the bottom and a
 ///       sort usually follows which causes a layout change to be fired.
 //   m_model->nodesAboutToBeAdded(this, m_children.size(), 1);
   a_child->m_parentNode = this;
   m_children.push_back(a_child);
 //   m_model->nodesAdded(this);
 }
 
 void Node::removeNode(Node* a_child)
 {
   int row = a_child->row();
   m_model->nodesAboutToBeRemoved(this, row, row);
   m_children.removeAt(row);
   delete a_child;
   m_model->nodesRemoved(this);
 }
 
 // Sort algorithm for the nodes.
 struct SortNodesFunctor
 {
   bool operator() (Node* a_lhs, Node* a_rhs)
   {
-    if ( a_lhs->getScore() == a_rhs->getScore() )
+    if ( a_lhs->score() == a_rhs->score() )
     {
-      return a_lhs->getSortableString() < a_rhs->getSortableString();
+      return a_lhs->sortableString() < a_rhs->sortableString();
     }
     else
-      return a_lhs->getScore() < a_rhs->getScore();
+      return a_lhs->score() < a_rhs->score();
   }
 };
 
 void Node::recursiveSortInternal()
 {
   // Sort my nodes.
   std::sort(m_children.begin(), m_children.end(), SortNodesFunctor());
 
   // Tell each node to sort it self.
   foreach (Node* node, m_children)
     node->recursiveSortInternal();
 }
 
 void Node::recursiveSort()
 {
   m_model->nodesLayoutAboutToBeChanged(this);
 
   recursiveSortInternal();
 
   m_model->nodesLayoutChanged(this);
 }
 
 int Node::row()
 {
   if ( m_parentNode == nullptr )
     return -1;
 
   return m_parentNode->m_children.indexOf(this);
 }
 
-QIcon ClassModelNodes::Node::getCachedIcon()
+QIcon ClassModelNodes::Node::cachedIcon()
 {
   // Load the cached icon if it's null.
   if ( m_cachedIcon.isNull() )
   {
     if ( !getIcon(m_cachedIcon) )
       m_cachedIcon = QIcon();
   }
 
   return m_cachedIcon;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 DynamicNode::DynamicNode(const QString& a_displayName, NodesModelInterface* a_model)
   : Node(a_displayName, a_model)
   , m_populated(false)
 {
 
 }
 
 void DynamicNode::collapse()
 {
   performNodeCleanup();
 }
 
 void DynamicNode::expand()
 {
   performPopulateNode();
 }
 
 void DynamicNode::performNodeCleanup()
 {
   if ( !m_populated )
     return;
 
   if ( !m_children.empty() )
   {
     // Notify model for this node.
     m_model->nodesAboutToBeRemoved(this, 0, m_children.size()-1);
 
     // Clear sub-nodes.
     clear();
 
     m_model->nodesRemoved(this);
   }
 
   // This shouldn't be called from clear since clear is called also from the d-tor
   // and the function is virtual.
   nodeCleared();
 
   // Mark the fact that we've been collapsed
   m_populated = false;
 }
 
 void DynamicNode::performPopulateNode(bool a_forceRepopulate)
 {
   if ( m_populated )
   {
     if ( a_forceRepopulate )
       performNodeCleanup();
     else
       return;
   }
 
   populateNode();
 
   // We're populated.
   m_populated = true;
 
   // Sort the list.
   recursiveSort();
 }
 
 bool DynamicNode::hasChildren() const
 {
   // To get a true status, we'll need to populate the node.
   const_cast<DynamicNode*>(this)->performPopulateNode();
 
   return !m_children.empty();
 }
 
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
diff --git a/kdevplatform/language/classmodel/classmodelnode.h b/kdevplatform/language/classmodel/classmodelnode.h
index e4d79d23e5..008ad7f997 100644
--- a/kdevplatform/language/classmodel/classmodelnode.h
+++ b/kdevplatform/language/classmodel/classmodelnode.h
@@ -1,333 +1,333 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2007-2009 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_CLASSMODELNODE_H
 #define KDEVPLATFORM_CLASSMODELNODE_H
 
 #include "classmodel.h"
 
 #include "../duchain/identifier.h"
 #include "../duchain/duchainpointer.h"
 #include "classmodelnodescontroller.h"
 
 #include <QIcon>
 
 class NodesModelInterface;
 
 namespace KDevelop
 {
   class ClassDeclaration;
   class ClassFunctionDeclaration;
   class ClassMemberDeclaration;
   class Declaration;
 }
 
 namespace ClassModelNodes
 {
 
 /// Base node class - provides basic functionality.
 class Node
 {
 public:
   Node(const QString& a_displayName, NodesModelInterface* a_model);
   virtual ~Node();
 
 public: // Operations
   /// Clear all the children from the node.
   void clear();
 
   /// Called by the model to collapse the node and remove sub-items if needed.
   virtual void collapse() {};
 
   /// Called by the model to expand the node and populate it with sub-nodes if needed.
   virtual void expand() {};
 
   /// Append a new child node to the list.
   void addNode(Node* a_child);
 
   /// Remove child node from the list and delete it.
   void removeNode(Node* a_child);
 
   /// Remove this node and delete it.
   void removeSelf() { m_parentNode->removeNode(this); }
 
   /// Called once the node has been populated to sort the entire tree / branch.
   void recursiveSort();
 
 public: // Info retrieval
   /// Return the parent associated with this node.
-  Node* getParent() const { return m_parentNode; }
+  Node* parent() const { return m_parentNode; }
 
   /// Get my index in the parent node
   int row();
 
   /// Return the display name for the node.
   QString displayName() const { return m_displayName; }
 
   /// Returns a list of child nodes
-  const QList<Node*>& getChildren() const { return m_children; }
+  const QList<Node*>& children() const { return m_children; }
 
   /// Return an icon representation for the node.
   /// @note It calls the internal getIcon and caches the result.
-  QIcon getCachedIcon();
+  QIcon cachedIcon();
 
 public: // overridables
   /// Return a score when sorting the nodes.
-  virtual int getScore() const = 0;
+  virtual int score() const = 0;
 
   /// Return true if the node contains sub-nodes.
   virtual bool hasChildren() const { return !m_children.empty(); }
 
   /// We use this string when sorting items.
-  virtual QString getSortableString() const { return m_displayName; }
+  virtual QString sortableString() const { return m_displayName; }
 
 protected:
   /// fill a_resultIcon with a display icon for the node.
   /// @param a_resultIcon returned icon.
   /// @return true if result was returned.
   virtual bool getIcon(QIcon& a_resultIcon) = 0;
 
 private:
   Node* m_parentNode;
 
   /// Called once the node has been populated to sort the entire tree / branch.
   void recursiveSortInternal();
 
 protected:
   typedef QList< Node* > NodesList;
   NodesList m_children;
   QString m_displayName;
   QIcon m_cachedIcon;
   NodesModelInterface* m_model;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Base class for nodes that generate and populate their child nodes dynamically
 class DynamicNode : public Node
 {
 public:
   DynamicNode(const QString& a_displayName, NodesModelInterface* a_model);
 
   /// Return true if the node was populated already.
   bool isPopulated() const { return m_populated; }
 
   /// Populate the node and mark the flag - called from expand or can be used internally.
   void performPopulateNode(bool a_forceRepopulate = false);
 
 public: // Node overrides.
   void collapse() override;
   void expand() override;
   bool hasChildren() const override;
 
 protected: // overridables
   /// Called by the framework when the node is about to be expanded
   /// it should be populated with sub-nodes if applicable.
   virtual void populateNode() {}
 
   /// Called after the nodes have been removed.
   /// It's for derived classes to clean cached data.
   virtual void nodeCleared() {}
 
 private:
   bool m_populated;
 
   /// Clear all the child nodes and mark flag.
   void performNodeCleanup();
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Base class for nodes associated with a @ref KDevelop::QualifiedIdentifier
 class IdentifierNode : public DynamicNode
 {
 public:
   IdentifierNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model, const QString& a_displayName = QString());
 
 public:
   /// Returns the qualified identifier for this node by going through the tree
-  const KDevelop::IndexedQualifiedIdentifier& getIdentifier() const { return m_identifier; }
+  const KDevelop::IndexedQualifiedIdentifier& identifier() const { return m_identifier; }
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
 
 public: // Overridables
   /// Return the associated declaration
   /// @note DU CHAIN MUST BE LOCKED FOR READ
-  virtual KDevelop::Declaration* getDeclaration();
+  virtual KDevelop::Declaration* declaration();
 
 private:
   KDevelop::IndexedQualifiedIdentifier m_identifier;
   KDevelop::IndexedDeclaration m_indexedDeclaration;
   KDevelop::DeclarationPointer m_cachedDeclaration;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// A node that represents an enum value.
 class EnumNode : public IdentifierNode
 {
 public:
   EnumNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
 
 public: // Node overrides
-  int getScore() const override { return 102; }
+  int score() const override { return 102; }
   bool getIcon(QIcon& a_resultIcon) override;
   void populateNode() override;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides display for a single class.
 class ClassNode : public IdentifierNode, public ClassModelNodeDocumentChangedInterface
 {
 public:
   ClassNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
   ~ClassNode() override;
 
   /// Lookup a contained class and return the related node.
   /// @return the node pointer or 0 if non was found.
   ClassNode* findSubClass(const KDevelop::IndexedQualifiedIdentifier& a_id);
 
 public: // Node overrides
-  int getScore() const override { return 300; }
+  int score() const override { return 300; }
   void populateNode() override;
   void nodeCleared() override;
   bool hasChildren() const override { return true; }
 
 protected: // ClassModelNodeDocumentChangedInterface overrides
   void documentChanged(const KDevelop::IndexedString& a_file) override;
 
 private:
   typedef QMap< uint, Node* > SubIdentifiersMap;
   /// Set of known sub-identifiers. It's used for updates check.
   SubIdentifiersMap m_subIdentifiers;
 
   /// We use this variable to know if we've registered for change notification or not.
   KDevelop::IndexedString m_cachedUrl;
 
   /// Updates the node to reflect changes in the declaration.
   /// @note DU CHAIN MUST BE LOCKED FOR READ
   /// @return true if something was updated.
   bool updateClassDeclarations();
 
   /// Add "Base classes" and "Derived classes" folders, if needed
   /// @return true if one of the folders was added.
   bool addBaseAndDerived();
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides a display for a single class function.
 class FunctionNode : public IdentifierNode
 {
 public:
   FunctionNode(KDevelop::Declaration* a_decl, NodesModelInterface* a_model);
 
 public: // Node overrides
-  int getScore() const override { return 400; }
-  QString getSortableString() const override { return m_sortableString; }
+  int score() const override { return 400; }
+  QString sortableString() const override { return m_sortableString; }
 
 private:
   QString m_sortableString;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides display for a single class variable.
 class ClassMemberNode : public IdentifierNode
 {
 public:
   ClassMemberNode(KDevelop::ClassMemberDeclaration* a_decl, NodesModelInterface* a_model);
 
 public: // Node overrides
-  int getScore() const override { return 500; }
+  int score() const override { return 500; }
   bool getIcon(QIcon& a_resultIcon) override;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides a folder node with a static list of nodes.
 class FolderNode : public Node
 {
 public:
   FolderNode(const QString& a_displayName, NodesModelInterface* a_model);
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
-  int getScore() const override { return 100; }
+  int score() const override { return 100; }
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Provides a folder node with a dynamic list of nodes.
 class DynamicFolderNode : public DynamicNode
 {
 public:
   DynamicFolderNode(const QString& a_displayName, NodesModelInterface* a_model);
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
-  int getScore() const override { return 100; }
+  int score() const override { return 100; }
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Special folder - the parent is assumed to be a ClassNode.
 /// It then displays the base classes for the class it sits in.
 class BaseClassesFolderNode : public DynamicFolderNode
 {
 public:
   explicit BaseClassesFolderNode(NodesModelInterface* a_model);
 
 public: // Node overrides
   void populateNode() override;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Special folder - the parent is assumed to be a ClassNode.
 /// It then displays list of derived classes from the parent class.
 class DerivedClassesFolderNode : public DynamicFolderNode
 {
 public:
   explicit DerivedClassesFolderNode(NodesModelInterface* a_model);
 
 public: // Node overrides
   void populateNode() override;
 };
 
 } // namespace classModelNodes
 
 #endif
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
diff --git a/kdevplatform/language/classmodel/documentclassesfolder.cpp b/kdevplatform/language/classmodel/documentclassesfolder.cpp
index ba5f46166a..f2670a9436 100644
--- a/kdevplatform/language/classmodel/documentclassesfolder.cpp
+++ b/kdevplatform/language/classmodel/documentclassesfolder.cpp
@@ -1,453 +1,453 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "documentclassesfolder.h"
 
 #include "../duchain/declaration.h"
 #include "../duchain/duchainlock.h"
 #include "../duchain/duchain.h"
 #include "../duchain/persistentsymboltable.h"
 #include "../duchain/codemodel.h"
 
 #include <QIcon>
 #include <QTimer>
 
 #include <boost/foreach.hpp>
 
 using namespace KDevelop;
 using namespace ClassModelNodes;
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 /// Contains a static list of classes within the namespace.
 class ClassModelNodes::StaticNamespaceFolderNode : public Node
 {
 public:
   StaticNamespaceFolderNode(const KDevelop::QualifiedIdentifier& a_identifier, NodesModelInterface* a_model);
 
   /// Returns the qualified identifier for this node
   const KDevelop::QualifiedIdentifier& qualifiedIdentifier() const { return m_identifier; }
 
 public: // Node overrides
   bool getIcon(QIcon& a_resultIcon) override;
-  int getScore() const override { return 101; }
+  int score() const override { return 101; }
 
 private:
   /// The namespace identifier.
   KDevelop::QualifiedIdentifier m_identifier;
 };
 
 StaticNamespaceFolderNode::StaticNamespaceFolderNode(const KDevelop::QualifiedIdentifier& a_identifier, NodesModelInterface* a_model)
   : Node(a_identifier.last().toString(), a_model)
   , m_identifier(a_identifier)
 {
 
 }
 
 bool StaticNamespaceFolderNode::getIcon(QIcon& a_resultIcon)
 {
   static QIcon folderIcon = QIcon::fromTheme(QStringLiteral("namespace"));
   a_resultIcon = folderIcon;
   return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
 
 DocumentClassesFolder::OpenedFileClassItem::OpenedFileClassItem(const KDevelop::IndexedString& a_file, const KDevelop::IndexedQualifiedIdentifier& a_classIdentifier, ClassModelNodes::ClassNode* a_nodeItem)
   : file(a_file)
   , classIdentifier(a_classIdentifier)
   , nodeItem(a_nodeItem)
 {
 }
 
 DocumentClassesFolder::DocumentClassesFolder(const QString& a_displayName, NodesModelInterface* a_model)
   : DynamicFolderNode(a_displayName, a_model)
   , m_updateTimer( new QTimer(this) )
 {
   // this is the required delay.
   m_updateTimer->setInterval(2000);
   connect( m_updateTimer, &QTimer::timeout, this, &DocumentClassesFolder::updateChangedFiles);
 }
 
 void DocumentClassesFolder::updateChangedFiles()
 {
   bool hadChanges = false;
 
   // re-parse changed documents.
   foreach( const IndexedString& file, m_updatedFiles )
   {
     // Make sure it's one of the monitored files.
     if ( m_openFiles.contains(file) )
       hadChanges |= updateDocument(file);
   }
 
   // Processed all files.
   m_updatedFiles.clear();
 
   // Sort if had changes.
   if ( hadChanges )
     recursiveSort();
 }
 
 void DocumentClassesFolder::nodeCleared()
 {
   // Clear cached namespaces list (node was cleared).
   m_namespaces.clear();
 
   // Clear open files and classes list
   m_openFiles.clear();
   m_openFilesClasses.clear();
 
   // Stop the update timer.
   m_updateTimer->stop();
 }
 
 void DocumentClassesFolder::populateNode()
 {
     // Start updates timer
     m_updateTimer->start();
 }
 
-QSet< KDevelop::IndexedString > DocumentClassesFolder::getAllOpenDocuments()
+QSet<KDevelop::IndexedString> DocumentClassesFolder::allOpenDocuments() const
 {
   return m_openFiles;
 }
 
 ClassNode* DocumentClassesFolder::findClassNode(const IndexedQualifiedIdentifier& a_id)
 {
   // Make sure that the classes node is populated, otherwise
   // the lookup will not work.
   performPopulateNode();
 
   ClassIdentifierIterator iter = m_openFilesClasses.get<ClassIdentifierIndex>().find(a_id);
   if ( iter == m_openFilesClasses.get<ClassIdentifierIndex>().end() )
     return nullptr;
 
   // If the node is invisible - make it visible by going over the identifiers list.
   if ( iter->nodeItem == nullptr )
   {
     QualifiedIdentifier qualifiedIdentifier = a_id.identifier();
 
     // Ignore zero length identifiers.
     if ( qualifiedIdentifier.count() == 0 )
       return nullptr;
     
     ClassNode* closestNode = nullptr;
     int closestNodeIdLen = qualifiedIdentifier.count();
 
     // First find the closest visible class node by reverse iteration over the id list.
     while ( (closestNodeIdLen > 0) && (closestNode == nullptr) )
     {
       // Omit one from the end.
       --closestNodeIdLen;
       
       // Find the closest class.
       closestNode = findClassNode(qualifiedIdentifier.mid(0, closestNodeIdLen));
     }
 
     if ( closestNode != nullptr )
     {
       // Start iterating forward from this node by exposing each class.
       // By the end of this loop, closestNode should hold the actual node.
       while ( closestNode && (closestNodeIdLen < qualifiedIdentifier.count()) )
       {
         // Try the next Id.
         ++closestNodeIdLen;
         closestNode = closestNode->findSubClass(qualifiedIdentifier.mid(0, closestNodeIdLen));
       }
     }
     
     return closestNode;
   }
   
   return iter->nodeItem;
 }
 
 void DocumentClassesFolder::closeDocument(const IndexedString& a_file)
 {
    // Get list of nodes associated with this file and remove them.
   std::pair< FileIterator, FileIterator > range = m_openFilesClasses.get<FileIndex>().equal_range( a_file );
   if ( range.first != m_openFilesClasses.get<FileIndex>().end() )
   {
     BOOST_FOREACH( const OpenedFileClassItem& item, range )
     {
       if ( item.nodeItem )
         removeClassNode(item.nodeItem);
     }
 
     // Clear the lists
     m_openFilesClasses.get<FileIndex>().erase(range.first, range.second);
   }
 
   // Clear the file from the list of monitored documents.
    m_openFiles.remove(a_file);
 }
 
 bool DocumentClassesFolder::updateDocument(const KDevelop::IndexedString& a_file)
 {
   uint codeModelItemCount = 0;
   const CodeModelItem* codeModelItems;
   CodeModel::self().items(a_file, codeModelItemCount, codeModelItems);
 
   // List of declared namespaces in this file.
   QSet< QualifiedIdentifier > declaredNamespaces;
 
   // List of removed classes - it initially contains all the known classes, we'll eliminate them
   // one by one later on when we encounter them in the document.
   QMap< IndexedQualifiedIdentifier, FileIterator > removedClasses;
   {
     std::pair< FileIterator, FileIterator > range = m_openFilesClasses.get<FileIndex>().equal_range( a_file );
     for ( FileIterator iter = range.first;
           iter != range.second;
           ++iter )
     {
       removedClasses.insert(iter->classIdentifier, iter);
     }
   }
 
   bool documentChanged = false;
 
   for(uint codeModelItemIndex = 0; codeModelItemIndex < codeModelItemCount; ++codeModelItemIndex)
   {
     const CodeModelItem& item = codeModelItems[codeModelItemIndex];
 
     // Don't insert unknown or forward declarations into the class browser
     if ( item.kind == CodeModelItem::Unknown || (item.kind & CodeModelItem::ForwardDeclaration) )
       continue;
 
     KDevelop::QualifiedIdentifier id = item.id.identifier();
 
     // Don't add empty identifiers.
     if ( id.count() == 0 )
       continue;
 
     // If it's a namespace, create it in the list.
     if ( item.kind & CodeModelItem::Namespace )
     {
       // This should create the namespace folder and add it to the cache.
-      getNamespaceFolder(id);
+      namespaceFolder(id);
 
       // Add to the locally created namespaces.
       declaredNamespaces.insert(id);
     }
     else if ( item.kind & CodeModelItem::Class )
     {
       // Ignore empty unnamed classes.
       if ( id.last().toString().isEmpty() )
         continue;
     
       // See if it matches our filter?
       if ( isClassFiltered(id) )
         continue;
 
       // Is this a new class or an existing class?
       if ( removedClasses.contains(id) )
       {
         // It already exist - remove it from the known classes and continue.
         removedClasses.remove(id);
         continue;
       }
 
       // Where should we put this class?
       Node* parentNode = nullptr;
 
       // Check if it's namespaced and add it to the proper namespace.
       if ( id.count() > 1 )
       {
         QualifiedIdentifier parentIdentifier(id.left(-1));
 
         // Look up the namespace in the cache.
         // If we fail to find it we assume that the parent context is a class
         // and in that case, when the parent class gets expanded, it will show it.
         NamespacesMap::iterator iter = m_namespaces.find(parentIdentifier);
         if ( iter != m_namespaces.end() )
         {
           // Add to the namespace node.
           parentNode = iter.value();
         }
         else
         {
           // Reaching here means we didn't encounter any namespace declaration in the document
           // But a class might still be declared under a namespace.
           // So we'll perform a more through search to see if it's under a namespace.
 
           DUChainReadLocker readLock(DUChain::lock());
 
           uint declsCount = 0;
           const IndexedDeclaration* decls;
           PersistentSymbolTable::self().declarations(parentIdentifier, declsCount, decls);
 
           for ( uint i = 0; i < declsCount; ++i )
           {
             // Look for the first valid declaration.
             if ( decls->declaration() )
             {
               // See if it should be namespaced.
               if ( decls->declaration()->kind() == Declaration::Namespace )
               {
                 // This should create the namespace folder and add it to the cache.
-                parentNode = getNamespaceFolder(parentIdentifier);
+                parentNode = namespaceFolder(parentIdentifier);
                 
                 // Add to the locally created namespaces.
                 declaredNamespaces.insert(parentIdentifier);
               }
               
               break;
             }
           }
         }
       }
       else
       {
         // Add to the main root.
         parentNode = this;
       }
 
       ClassNode* newNode = nullptr;
       if ( parentNode != nullptr )
       {
         // Create the new node and add it.
         IndexedDeclaration decl;
         uint count = 0;
         const IndexedDeclaration* declarations;
         DUChainReadLocker lock;
         PersistentSymbolTable::self().declarations(item.id, count, declarations);
         for ( uint i = 0; i < count; ++i )
         {
           if (declarations[i].indexedTopContext().url() == a_file)
           {
             decl = declarations[i];
             break;
           }
         }
         if (decl.isValid())
         {
           newNode = new ClassNode(decl.declaration(), m_model);
           parentNode->addNode( newNode );
         }
       }
 
       // Insert it to the map - newNode can be 0 - meaning the class is hidden.
       m_openFilesClasses.insert( OpenedFileClassItem( a_file, id, newNode ) );
       documentChanged = true;
     }
   }
 
   // Remove empty namespaces from the list.
   // We need this because when a file gets unloaded, we unload the declared classes in it
   // and if a namespace has no class in it, it'll forever exist and no one will remove it
   // from the children list.
   foreach( const QualifiedIdentifier& id, declaredNamespaces )
     removeEmptyNamespace(id);
 
   // Clear erased classes.
   foreach( const FileIterator item, removedClasses )
   {
     if ( item->nodeItem )
       removeClassNode(item->nodeItem);
     m_openFilesClasses.get<FileIndex>().erase(item);
     documentChanged = true;
   }
 
   return documentChanged;
 }
 
 void DocumentClassesFolder::parseDocument(const IndexedString& a_file)
 {
   // Add the document to the list of open files - this means we monitor it.
   if ( !m_openFiles.contains(a_file) )
     m_openFiles.insert(a_file);
 
   updateDocument(a_file);
 }
 
 void DocumentClassesFolder::removeClassNode(ClassModelNodes::ClassNode* a_node)
 {
   // Get the parent namespace identifier.
   QualifiedIdentifier parentNamespaceIdentifier;
-  if ( auto namespaceParent = dynamic_cast<StaticNamespaceFolderNode*>(a_node->getParent()) )
+  if ( auto namespaceParent = dynamic_cast<StaticNamespaceFolderNode*>(a_node->parent()) )
   {
     parentNamespaceIdentifier = namespaceParent->qualifiedIdentifier();
   }
 
   // Remove the node.
   a_node->removeSelf();
 
   // Remove empty namespace
   removeEmptyNamespace(parentNamespaceIdentifier);
 }
 
 void DocumentClassesFolder::removeEmptyNamespace(const QualifiedIdentifier& a_identifier)
 {
   // Stop condition.
   if ( a_identifier.count() == 0 )
     return;
 
   // Look it up in the cache.
   NamespacesMap::iterator iter = m_namespaces.find(a_identifier);
   if ( iter != m_namespaces.end() )
   {
     if ( !(*iter)->hasChildren() )
     {
       // Remove this node and try to remove the parent node.
       QualifiedIdentifier parentIdentifier = (*iter)->qualifiedIdentifier().left(-1);
       (*iter)->removeSelf();
       m_namespaces.remove(a_identifier);
       removeEmptyNamespace(parentIdentifier);
     }
   }
 }
 
-StaticNamespaceFolderNode* DocumentClassesFolder::getNamespaceFolder(const KDevelop::QualifiedIdentifier& a_identifier)
+StaticNamespaceFolderNode* DocumentClassesFolder::namespaceFolder(const KDevelop::QualifiedIdentifier& a_identifier)
 {
   // Stop condition.
   if ( a_identifier.count() == 0 )
     return nullptr;
 
   // Look it up in the cache.
   NamespacesMap::iterator iter = m_namespaces.find(a_identifier);
   if ( iter == m_namespaces.end() )
   {
     // It's not in the cache - create folders up to it.
-    Node* parentNode = getNamespaceFolder(a_identifier.left(-1));
+    Node* parentNode = namespaceFolder(a_identifier.left(-1));
     if ( parentNode == nullptr )
       parentNode = this;
 
     // Create the new node.
     StaticNamespaceFolderNode* newNode =
       new StaticNamespaceFolderNode(a_identifier, m_model);
     parentNode->addNode( newNode );
 
     // Add it to the cache.
     m_namespaces.insert( a_identifier, newNode );
 
     // Return the result.
     return newNode;
   }
   else
     return *iter;
 }
 
 
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
diff --git a/kdevplatform/language/classmodel/documentclassesfolder.h b/kdevplatform/language/classmodel/documentclassesfolder.h
index 85902050cb..c591e52edf 100644
--- a/kdevplatform/language/classmodel/documentclassesfolder.h
+++ b/kdevplatform/language/classmodel/documentclassesfolder.h
@@ -1,155 +1,155 @@
 /*
  * KDevelop Class Browser
  *
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_DOCUMENTCLASSESFOLDER_H
 #define KDEVPLATFORM_DOCUMENTCLASSESFOLDER_H
 
 #include "classmodelnode.h"
 #include <boost/multi_index_container.hpp>
 #include <boost/multi_index/member.hpp>
 #include <boost/multi_index/ordered_index.hpp>
 
 namespace ClassModelNodes
 {
 
 class StaticNamespaceFolderNode;
 
 /// This folder displays all the classes that relate to a list of documents.
 class DocumentClassesFolder : public QObject, public DynamicFolderNode
 {
   Q_OBJECT
 public:
   DocumentClassesFolder(const QString& a_displayName, NodesModelInterface* a_model);
 
 public: // Operations
   /// Find a class node in the lists by its id.
   ClassNode* findClassNode(const KDevelop::IndexedQualifiedIdentifier& a_id);
 
 protected: // Documents list handling.
   /// Parse a single document for classes and add them to the list.
   void parseDocument(const KDevelop::IndexedString& a_file);
 
   /// Re-parse the given document - remove old declarations and add new declarations.
   bool updateDocument(const KDevelop::IndexedString& a_file);
 
   /// Close and remove all the nodes related to the specified document.
   void closeDocument(const KDevelop::IndexedString& a_file);
 
   /// Returns a list of documents we have monitored.
-  QSet< KDevelop::IndexedString > getAllOpenDocuments();
+  QSet<KDevelop::IndexedString> allOpenDocuments() const;
 
 protected: // Overridables
   /// Override this to filter the found classes.
   virtual bool isClassFiltered(const KDevelop::QualifiedIdentifier&) { return false; }
   
 public: // Node overrides
   void nodeCleared() override;
   void populateNode() override;
   bool hasChildren() const override { return true; }
 
 private Q_SLOTS:
   // Files update.
   void updateChangedFiles();
 
 private: // File updates related.
   /// List of updated files we check this list when update timer expires.
   QSet<KDevelop::IndexedString> m_updatedFiles;
 
   /// Timer for batch updates.
   QTimer* m_updateTimer;
 
 private: // Opened class identifiers container definition.
   // An opened class item.
   struct OpenedFileClassItem
   {
     OpenedFileClassItem();
     OpenedFileClassItem(const KDevelop::IndexedString& a_file,
                         const KDevelop::IndexedQualifiedIdentifier& a_classIdentifier,
                         ClassNode* a_nodeItem);
 
     /// The file this class declaration comes from.
     KDevelop::IndexedString file;
 
     /// The identifier for this class.
     KDevelop::IndexedQualifiedIdentifier classIdentifier;
 
     /// An existing node item. It maybe 0 - meaning the class node is currently hidden.
     ClassNode* nodeItem;
   };
 
   // Index definitions.
   struct FileIndex {};
   struct ClassIdentifierIndex {};
 
   // Member types definitions.
   typedef boost::multi_index::member<
     OpenedFileClassItem,
     KDevelop::IndexedString,
     &OpenedFileClassItem::file> FileMember;
   typedef boost::multi_index::member<
     OpenedFileClassItem,
     KDevelop::IndexedQualifiedIdentifier,
     &OpenedFileClassItem::classIdentifier> ClassIdentifierMember;
 
   // Container definition.
   typedef boost::multi_index::multi_index_container<
     OpenedFileClassItem,
     boost::multi_index::indexed_by<
       boost::multi_index::ordered_non_unique<
         boost::multi_index::tag<FileIndex>,
         FileMember
       >,
       boost::multi_index::ordered_unique<
         boost::multi_index::tag<ClassIdentifierIndex>,
         ClassIdentifierMember
       >
     >
   > OpenFilesContainer;
 
   // Iterators definition.
   typedef OpenFilesContainer::index_iterator<FileIndex>::type FileIterator;
   typedef OpenFilesContainer::index_iterator<ClassIdentifierIndex>::type ClassIdentifierIterator;
 
   /// Maps all displayed classes and their referenced files.
   OpenFilesContainer m_openFilesClasses;
 
   /// Holds a set of open files.
   QSet< KDevelop::IndexedString > m_openFiles;
 
 private:
   typedef QMap< KDevelop::IndexedQualifiedIdentifier, StaticNamespaceFolderNode* > NamespacesMap;
   /// Holds a map between an identifier and a namespace folder we hold.
   NamespacesMap m_namespaces;
 
   /// Recursively create a namespace folder for the specified identifier if it doesn't
   /// exist, cache it and return it (or just return it from the cache).
-  StaticNamespaceFolderNode* getNamespaceFolder(const KDevelop::QualifiedIdentifier& a_identifier);
+  StaticNamespaceFolderNode* namespaceFolder(const KDevelop::QualifiedIdentifier& a_identifier);
 
   /// Removes the given namespace identifier recursively if it's empty.
   void removeEmptyNamespace(const KDevelop::QualifiedIdentifier& a_identifier);
 
   /// Remove a single class node from the lists.
   void removeClassNode(ClassNode* a_node);
 };
 
 } // namespace ClassModelNodes
 
 #endif // KDEVPLATFORM_DOCUMENTCLASSESFOLDER_H
diff --git a/kdevplatform/language/codecompletion/codecompletiontesthelper.h b/kdevplatform/language/codecompletion/codecompletiontesthelper.h
index 02a191a938..b3a2cdc5d9 100644
--- a/kdevplatform/language/codecompletion/codecompletiontesthelper.h
+++ b/kdevplatform/language/codecompletion/codecompletiontesthelper.h
@@ -1,236 +1,237 @@
 /* This file is part of KDevelop
     Copyright 2006 Hamish Rodda<rodda@kde.org>
     Copyright 2007-2009 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_CODECOMPLETIONTESTHELPER_H
 #define KDEVPLATFORM_CODECOMPLETIONTESTHELPER_H
 
 #include <QTest>
 #include <QStandardItemModel>
 
 #include "../duchain/declaration.h"
 #include "../duchain/duchain.h"
 #include "codecompletionitem.h"
 #include <language/codegen/coderepresentation.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/parsingenvironment.h>
 
 #include <tests/testhelpers.h>
 
 using namespace KTextEditor;
 
 using namespace KDevelop;
 
 /**
   * Helper-class for testing completion-items
   * Just initialize it with the context and the text, and then use the members, for simple cases only "names"
   * the template parameter is your language specific CodeCompletionContext
   */
 template <class T>
 struct CodeCompletionItemTester
 {
   using Element = QExplicitlySharedDataPointer<KDevelop::CompletionTreeElement>;
   using Item = QExplicitlySharedDataPointer<KDevelop::CompletionTreeItem>;
   using Context = QExplicitlySharedDataPointer<T>;
 
   //Standard constructor
   CodeCompletionItemTester(DUContext* context, const QString& text = QStringLiteral("; "), const QString& followingText = QString(),
                            const CursorInRevision& position = CursorInRevision::invalid())
     : completionContext(new T(DUContextPointer(context), text, followingText,
                               position.isValid() ? position : context->range().end))
   {
     init();
   }
 
   //Can be used if you already have the completion context
   CodeCompletionItemTester(const Context& context)
     : completionContext(context)
   {
     init();
   }
 
   //Creates a CodeCompletionItemTester for the parent context
   CodeCompletionItemTester parent() const
   {
     Context parent = Context(dynamic_cast<T*>(completionContext->parentContext()));
     Q_ASSERT(parent);
     return CodeCompletionItemTester(parent);
   }
 
   void addElements(const QList<Element>& elements)
   {
     for (auto& element : elements) {
       Item item(dynamic_cast<CompletionTreeItem*>(element.data()));
       if(item)
         items << item;
       CompletionTreeNode* node = dynamic_cast<CompletionTreeNode*>(element.data());
       if(node)
         addElements(node->children);
     }
   }
 
   bool containsDeclaration(Declaration* dec) const
   {
     for (auto& item : items) {
         if (item->declaration().data() == dec) {
             return true;
         }
     }
     return false;
   }
 
   QList<Item> items; // All items retrieved
   QStringList names; // Names of all completion-items
   Context completionContext;
 
   //Convenience-function to retrieve data from completion-items by name
   QVariant itemData(const QString& itemName, int column = KTextEditor::CodeCompletionModel::Name, int role = Qt::DisplayRole) const
   {
     return itemData(names.indexOf(itemName), column, role);
   }
 
   QVariant itemData(int itemNumber, int column = KTextEditor::CodeCompletionModel::Name, int role = Qt::DisplayRole) const
   {
     if(itemNumber < 0 || itemNumber >= items.size())
       return QVariant();
 
     return itemData(items[itemNumber], column, role);
   }
 
   QVariant itemData(Item item, int column = KTextEditor::CodeCompletionModel::Name, int role = Qt::DisplayRole) const
   {
     return item->data(fakeModel().index(0, column), role, nullptr);
   }
 
   Item findItem(const QString& itemName) const
   {
     const auto idx = names.indexOf(itemName);
     if (idx < 0) {
       return {};
     }
     return items[idx];
   }
 
   private:
     void init()
     {
       if ( !completionContext || !completionContext->isValid() ) {
         qWarning() << "invalid completion context";
         return;
       }
 
       bool abort = false;
       items = completionContext->completionItems(abort);
 
       addElements(completionContext->ungroupedElements());
 
       names.reserve(items.size());
       foreach(Item i, items) {
         names << i->data(fakeModel().index(0, KTextEditor::CodeCompletionModel::Name), Qt::DisplayRole, nullptr).toString();
       }
     }
 
     static QStandardItemModel& fakeModel()
     {
       static QStandardItemModel model;
       model.setColumnCount(10);
       model.setRowCount(10);
       return model;
     }
 };
 
 /**
  * Helper class that inserts the given text into the duchain under the specified name,
  * allows parsing it with a simple call to parse(), and automatically releases the top-context
  *
  * The duchain must not be locked when this object is destroyed
  */
 struct InsertIntoDUChain
 {
   ///Artificially inserts a file called @p name with the text @p text
   InsertIntoDUChain(const QString& name, const QString& text) : m_insertedCode(IndexedString(name), text), m_topContext(nullptr) {
   }
 
   ~InsertIntoDUChain() {
     get();
     release();
   }
 
   ///The duchain must not be locked when this is called
   void release() {
     if(m_topContext) {
       DUChainWriteLocker lock;
 
       m_topContext = nullptr;
 
       const QList<TopDUContext*> chains = DUChain::self()->chainsForDocument(m_insertedCode.file());
       for (TopDUContext* top : chains) {
         DUChain::self()->removeDocumentChain(top);
       }
     }
   }
 
   TopDUContext* operator->() {
     get();
     return m_topContext.data();
   }
 
   TopDUContext* tryGet() {
       DUChainReadLocker lock;
     return DUChain::self()->chainForDocument(m_insertedCode.file(), false);
   }
 
   void get() {
     if(!m_topContext)
       m_topContext = tryGet();
   }
 
   ///Helper function: get a declaration based on its qualified identifier
-  Declaration* getDeclaration(const QString& id) {
+  Declaration* declaration(const QString& id)
+  {
     get();
     if(!topContext())
       return nullptr;
-    return DeclarationId(IndexedQualifiedIdentifier(QualifiedIdentifier(id))).getDeclaration(topContext());
+    return DeclarationId(IndexedQualifiedIdentifier(QualifiedIdentifier(id))).declaration(topContext());
   }
 
   TopDUContext* topContext() {
     return m_topContext.data();
   }
 
   /**
     * Parses this inserted code as a stand-alone top-context
     * The duchain must not be locked when this is called
     *
     * @param features The features that should be requested for the top-context
     * @param update Whether the top-context should be updated if it already exists. Else it will be deleted.
     */
   void parse(uint features = TopDUContext::AllDeclarationsContextsAndUses, bool update = false) {
 
     if(!update)
       release();
     m_topContext = DUChain::self()->waitForUpdate(m_insertedCode.file(), (TopDUContext::Features)features, false);
     Q_ASSERT(m_topContext);
     DUChainReadLocker lock;
     Q_ASSERT(!m_topContext->parsingEnvironmentFile()->isProxyContext());
   }
 
   InsertArtificialCodeRepresentation m_insertedCode;
   ReferencedTopDUContext m_topContext;
 };
 
 #endif // KDEVPLATFORM_CODECOMPLETIONTESTHELPER_H
diff --git a/kdevplatform/language/codegen/codedescription.cpp b/kdevplatform/language/codegen/codedescription.cpp
index 3a942b7cb7..9950cfac02 100644
--- a/kdevplatform/language/codegen/codedescription.cpp
+++ b/kdevplatform/language/codegen/codedescription.cpp
@@ -1,186 +1,186 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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 "codedescription.h"
 #include <debug.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <language/duchain/functiondeclaration.h>
 
 #include <KLocalizedString>
 
 using namespace KDevelop;
 
 /**
  * The access policy as a string, or an empty string
  * if the policy is set to default
  *
  * The DUChain must be locked when calling this function
  **/
 QString accessPolicyName(const DeclarationPointer& declaration)
 {
     DUChainPointer<ClassMemberDeclaration> member = declaration.dynamicCast<ClassMemberDeclaration>();
     if (member)
     {
         switch (member->accessPolicy())
         {
             case Declaration::Private:
                 return QStringLiteral("private");
             case Declaration::Protected:
                 return QStringLiteral("protected");
             case Declaration::Public:
                 return QStringLiteral("public");
             default:
                 break;
         }
     }
     return QString();
 }
 
 VariableDescription::VariableDescription()
 {
 
 }
 
 VariableDescription::VariableDescription(const QString& type, const QString& name)
 : name(name)
 , type(type)
 {
 
 }
 
 VariableDescription::VariableDescription(const DeclarationPointer& declaration)
 {
     DUChainReadLocker lock;
 
     if (declaration)
     {
         name = declaration->identifier().toString();
         if (auto abstractType = declaration->abstractType()) {
             type = abstractType->toString();
         }
     }
 
     access = accessPolicyName(declaration);
 }
 
 FunctionDescription::FunctionDescription()
     : FunctionDescription::FunctionDescription({}, {}, {})
 {
 }
 
 FunctionDescription::FunctionDescription(const QString& name, const VariableDescriptionList& arguments,
                                          const VariableDescriptionList& returnArguments)
 : name(name)
 , arguments(arguments)
 , returnArguments(returnArguments)
 , isConstructor(false)
 , isDestructor(false)
 , isVirtual(false)
 , isStatic(false)
 , isSlot(false)
 , isSignal(false)
 , isConst(false)
 {
 }
 
 FunctionDescription::FunctionDescription(const DeclarationPointer& declaration)
     : FunctionDescription::FunctionDescription({}, {}, {})
 {
     DUChainReadLocker lock;
 
     if (declaration)
     {
         name = declaration->identifier().toString();
         DUContext* context = declaration->internalContext();
 
         DUChainPointer<FunctionDeclaration> function = declaration.dynamicCast<FunctionDeclaration>();
         if (function)
         {
-            context = DUChainUtils::getArgumentContext(declaration.data());
+            context = DUChainUtils::argumentContext(declaration.data());
         }
 
         DUChainPointer<ClassFunctionDeclaration> method = declaration.dynamicCast<ClassFunctionDeclaration>();
 
         if (method)
         {
             isConstructor = method->isConstructor();
             isDestructor = method->isDestructor();
             isVirtual = method->isVirtual();
             isAbstract = method->isAbstract();
             isFinal = method->isFinal();
-            isOverriding = (DUChainUtils::getOverridden(method.data()) != nullptr);
+            isOverriding = (DUChainUtils::overridden(method.data()) != nullptr);
             isStatic = method->isStatic();
             isSlot = method->isSlot();
             isSignal = method->isSignal();
         }
 
         int i = 0;
         const auto localDeclarations = context->localDeclarations();
         arguments.reserve(localDeclarations.size());
         for (Declaration* arg : localDeclarations) {
             VariableDescription var = VariableDescription(DeclarationPointer(arg));
             if (function)
             {
                 var.value = function->defaultParameterForArgument(i).str();
                 qCDebug(LANGUAGE) << var.name << var.value;
             }
             arguments << var;
             ++i;
         }
 
         FunctionType::Ptr functionType = declaration->abstractType().cast<FunctionType>();
 
         if (functionType)
         {
             isConst = (functionType->modifiers() & AbstractType::ConstModifier);
         }
 
         if (functionType && functionType->returnType())
         {
             returnArguments << VariableDescription(functionType->returnType()->toString(), QString());
         }
 
         access = accessPolicyName(declaration);
     }
 }
 
 QString FunctionDescription::returnType() const
 {
     if (returnArguments.isEmpty())
     {
         return QString();
     }
     return returnArguments.first().type;
 }
 
 ClassDescription::ClassDescription()
 {
 
 }
 
 ClassDescription::ClassDescription(const QString& name)
 : name(name)
 {
 
 }
diff --git a/kdevplatform/language/codegen/templateclassgenerator.cpp b/kdevplatform/language/codegen/templateclassgenerator.cpp
index ad1db7a2d5..b392c05c29 100644
--- a/kdevplatform/language/codegen/templateclassgenerator.cpp
+++ b/kdevplatform/language/codegen/templateclassgenerator.cpp
@@ -1,334 +1,334 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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 "templateclassgenerator.h"
 #include "archivetemplateloader.h"
 #include <debug.h>
 
 #include <interfaces/iproject.h>
 #include "language/codegen/documentchangeset.h"
 #include "codedescription.h"
 #include "templaterenderer.h"
 #include "sourcefiletemplate.h"
 #include <duchain/declaration.h>
 #include <duchain/duchainlock.h>
 #include <duchain/persistentsymboltable.h>
 #include <duchain/types/structuretype.h>
 #include <project/projectmodel.h>
 
 #include <QFileInfo>
 
 using namespace KDevelop;
 
 /// @param base String such as 'public QObject' or 'QObject'
 InheritanceDescription descriptionFromString(const QString& base)
 {
     QStringList splitBase = base.split(QLatin1Char(' '));
     QString identifier = splitBase.takeLast();
     QString inheritanceMode = splitBase.join(QLatin1Char(' '));
 
     InheritanceDescription desc;
     desc.baseType = identifier;
     desc.inheritanceMode = inheritanceMode;
     return desc;
 }
 
 class KDevelop::TemplateClassGeneratorPrivate
 {
 public:
     SourceFileTemplate fileTemplate;
     QUrl baseUrl;
     TemplateRenderer renderer;
 
     QString name;
     QString identifier;
     QStringList namespaces;
     QString license;
 
     QHash<QString, QUrl> fileUrls;
     QHash<QString, KTextEditor::Cursor> filePositions;
     ClassDescription description;
 
     QList<DeclarationPointer> directBaseClasses;
     QList<DeclarationPointer> allBaseClasses;
 
     void fetchSuperClasses(const DeclarationPointer& declaration);
 };
 
 void TemplateClassGeneratorPrivate::fetchSuperClasses(const DeclarationPointer& declaration)
 {
     DUChainReadLocker lock;
 
     //Prevent duplicity
     if(allBaseClasses.contains(declaration))
     {
         return;
     }
 
     allBaseClasses << declaration;
 
     DUContext* context = declaration->internalContext();
     if (context) {
         foreach (const DUContext::Import& import, context->importedParentContexts()) {
             if (DUContext * parentContext = import.context(context->topContext())) {
                 if (parentContext->type() == DUContext::Class) {
                     fetchSuperClasses( DeclarationPointer(parentContext->owner()) );
                 }
             }
         }
     }
 }
 
 
 TemplateClassGenerator::TemplateClassGenerator(const QUrl& baseUrl)
  : d(new TemplateClassGeneratorPrivate)
 {
     Q_ASSERT(QFileInfo(baseUrl.toLocalFile()).isDir()); // assume folder
 
     d->baseUrl = baseUrl;
     d->renderer.setEmptyLinesPolicy(TemplateRenderer::TrimEmptyLines);
 }
 
 TemplateClassGenerator::~TemplateClassGenerator() = default;
 
 void TemplateClassGenerator::setTemplateDescription(const SourceFileTemplate& fileTemplate)
 {
     d->fileTemplate = fileTemplate;
     Q_ASSERT(fileTemplate.isValid());
 }
 
 DocumentChangeSet TemplateClassGenerator::generate()
 {
     return d->renderer.renderFileTemplate(d->fileTemplate, d->baseUrl, fileUrls());
 }
 
 QHash<QString, QString> TemplateClassGenerator::fileLabels() const
 {
     Q_ASSERT(d->fileTemplate.isValid());
     QHash<QString,QString> labels;
 
     foreach (const SourceFileTemplate::OutputFile& outputFile, d->fileTemplate.outputFiles())
     {
         labels.insert(outputFile.identifier, outputFile.label);
     }
 
     return labels;
 }
 
 TemplateClassGenerator::UrlHash TemplateClassGenerator::fileUrls() const
 {
     if (d->fileUrls.isEmpty())
     {
         foreach (const SourceFileTemplate::OutputFile& outputFile, d->fileTemplate.outputFiles())
         {
             QString outputName = d->renderer.render(outputFile.outputName, outputFile.identifier);
             QUrl url = d->baseUrl.resolved(QUrl(outputName));
             d->fileUrls.insert(outputFile.identifier, url);
         }
     }
 
     return d->fileUrls;
 }
 
 QUrl TemplateClassGenerator::baseUrl() const
 {
     return d->baseUrl;
 }
 
 QUrl TemplateClassGenerator::fileUrl(const QString& outputFile) const
 {
     return fileUrls().value(outputFile);
 }
 
 void TemplateClassGenerator::setFileUrl(const QString& outputFile, const QUrl& url)
 {
     d->fileUrls.insert(outputFile, url);
     d->renderer.addVariable(QLatin1String("output_file_") + outputFile.toLower(), QDir(d->baseUrl.path()).relativeFilePath(url.path()));
     d->renderer.addVariable(QLatin1String("output_file_") + outputFile.toLower() + QLatin1String("_absolute"), url.toLocalFile());
 }
 
 KTextEditor::Cursor TemplateClassGenerator::filePosition(const QString& outputFile) const
 {
     return d->filePositions.value(outputFile);
 }
 
 void TemplateClassGenerator::setFilePosition(const QString& outputFile, const KTextEditor::Cursor& position)
 {
     d->filePositions.insert(outputFile, position);
 }
 
 void TemplateClassGenerator::addVariables(const QVariantHash& variables)
 {
     d->renderer.addVariables(variables);
 }
 
 QString TemplateClassGenerator::renderString(const QString& text) const
 {
     return d->renderer.render(text);
 }
 
 SourceFileTemplate TemplateClassGenerator::sourceFileTemplate() const
 {
     return d->fileTemplate;
 }
 
 TemplateRenderer* TemplateClassGenerator::renderer() const
 {
     return &(d->renderer);
 }
 
 
 QString TemplateClassGenerator::name() const
 {
     return d->name;
 }
 
 void TemplateClassGenerator::setName(const QString& newName)
 {
     d->name = newName;
     d->renderer.addVariable(QStringLiteral("name"), newName);
 }
 
 QString TemplateClassGenerator::identifier() const
 {
     return name();
 }
 
 void TemplateClassGenerator::setIdentifier(const QString& identifier)
 {
     d->renderer.addVariable(QStringLiteral("identifier"), identifier);
     const QStringList separators{
         QStringLiteral("::"),
         QStringLiteral("."),
         QStringLiteral(":"),
         QStringLiteral("\\"),
         QStringLiteral("/"),
     };
     QStringList ns;
     for (const QString& separator : separators) {
         ns = identifier.split(separator);
         if (ns.size() > 1)
         {
             break;
         }
     }
     setName(ns.takeLast());
     setNamespaces(ns);
 }
 
 QStringList TemplateClassGenerator::namespaces() const
 {
     return d->namespaces;
 }
 
 void TemplateClassGenerator::setNamespaces(const QStringList& namespaces) const
 {
     d->namespaces = namespaces;
     d->renderer.addVariable(QStringLiteral("namespaces"), namespaces);
 }
 
 
 /// Specify license for this class
 void TemplateClassGenerator::setLicense(const QString& license)
 {
     qCDebug(LANGUAGE) << "New Class: " << d->name << "Set license: " << d->license;
     d->license = license;
     d->renderer.addVariable(QStringLiteral("license"), license);
 }
 
 /// Get the license specified for this classes
 QString TemplateClassGenerator::license() const
 {
     return d->license;
 }
 
 void TemplateClassGenerator::setDescription(const ClassDescription& description)
 {
     d->description = description;
 
     QVariantHash variables;
     variables[QStringLiteral("description")] = QVariant::fromValue(description);
     variables[QStringLiteral("members")] = CodeDescription::toVariantList(description.members);
     variables[QStringLiteral("functions")] = CodeDescription::toVariantList(description.methods);
     variables[QStringLiteral("base_classes")] = CodeDescription::toVariantList(description.baseClasses);
     d->renderer.addVariables(variables);
 }
 
 ClassDescription TemplateClassGenerator::description() const
 {
     return d->description;
 }
 
 void TemplateClassGenerator::addBaseClass(const QString& base)
 {
     const InheritanceDescription desc = descriptionFromString(base);
 
     ClassDescription cd = description();
     cd.baseClasses << desc;
     setDescription(cd);
 
     DUChainReadLocker lock;
 
-    PersistentSymbolTable::Declarations decl = PersistentSymbolTable::self().getDeclarations(IndexedQualifiedIdentifier(QualifiedIdentifier(desc.baseType)));
+    PersistentSymbolTable::Declarations decl = PersistentSymbolTable::self().declarations(IndexedQualifiedIdentifier(QualifiedIdentifier(desc.baseType)));
 
     //Search for all super classes
     for(PersistentSymbolTable::Declarations::Iterator it = decl.iterator(); it; ++it)
     {
         DeclarationPointer declaration = DeclarationPointer(it->declaration());
         if(declaration->isForwardDeclaration())
         {
             continue;
         }
 
         // Check if it's a class/struct/etc
         if(declaration->type<StructureType>())
         {
             d->fetchSuperClasses(declaration);
             d->directBaseClasses << declaration;
             break;
         }
     }
 }
 
 void TemplateClassGenerator::setBaseClasses(const QList<QString>& bases)
 {
     // clear
     ClassDescription cd = description();
     cd.baseClasses.clear();
     setDescription(cd);
 
     d->directBaseClasses.clear();
     d->allBaseClasses.clear();
 
     // add all bases
     for (const QString& base : bases) {
         addBaseClass(base);
     }
 }
 
 QList< DeclarationPointer > TemplateClassGenerator::directBaseClasses() const
 {
     return d->directBaseClasses;
 }
 
 QList< DeclarationPointer > TemplateClassGenerator::allBaseClasses() const
 {
     return d->allBaseClasses;
 }
 
diff --git a/kdevplatform/language/duchain/appendedlist.h b/kdevplatform/language/duchain/appendedlist.h
index 6c3cbf5e31..0f1f3215b3 100644
--- a/kdevplatform/language/duchain/appendedlist.h
+++ b/kdevplatform/language/duchain/appendedlist.h
@@ -1,394 +1,394 @@
 /*
    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 KDEVPLATFORM_APPENDEDLIST_H
 #define KDEVPLATFORM_APPENDEDLIST_H
 
 #include <QMutex>
 #include <QVector>
 
 #include <util/kdevvarlengtharray.h>
 #include <util/stack.h>
 
 #include <iostream>
 #include <time.h>
 
 namespace KDevelop {
 class AbstractItemRepository;
 /**
  * This file contains macros and classes that can be used to conveniently implement classes that store the data of an arbitrary count
  * of additional lists within the same memory block directly behind the class data, in a way that one the whole data can be stored by one copy-operation
  * to another place, like needed in ItemRepository. These macros simplify having two versions of a class: One that has its lists attached in memory,
  * and one version that has them contained as a directly accessible KDevVarLengthArray. Both versions have their lists accessible through access-functions,
  * have a completeSize() function that computes the size of the one-block version, and a copyListsFrom(..) function which can copy the lists from one
  * version to the other.
  *
  * @warning Always follow these rules:
  * \li You must call initializeAppendedLists(bool) on construction, also in any copy-constructor, but before calling copyFrom(..).
  * \li The parameter to that function should be whether the lists in the items should be dynamic, and thus most times "true".
  * \li You must call freeAppendedLists() on destruction, our you will be leaking memory(only when dynamic)
  *
  * For each embedded list, you must use macros to define a global hash that will be used to allocate the temporary lists.
  * For example in @c identifier.cpp we have:
  *
  * @code
  * DEFINE_LIST_MEMBER_HASH(IdentifierPrivate, templateIdentifiers, uint);
  * @endcode
  *
  * In general, see @c identifier.cpp for an example on how to use these macros.
  *
  * @todo Document this a bit more
  * */
 
 enum {
   DynamicAppendedListMask = 1 << 31
 };
 enum {
   DynamicAppendedListRevertMask = ~DynamicAppendedListMask
 };
 /**
  * Manages a repository of items for temporary usage. The items will be allocated with an index on alloc(),
  * and freed on free(index). When freed, the same index will be re-used for a later allocation, thus no real allocations
  * will be happening in most cases.
  * The returned indices will always be ored with DynamicAppendedListMask.
  *
  */
 template<class T, bool threadSafe = true>
 class TemporaryDataManager {
   public:
     explicit TemporaryDataManager(const QByteArray& id = {})
         : m_id(id)
     {
       int first = alloc();  //Allocate the zero item, just to reserve that index
       Q_ASSERT(first == (int)DynamicAppendedListMask);
       Q_UNUSED(first);
     }
     ~TemporaryDataManager() {
       free(DynamicAppendedListMask); //Free the zero index, so we don't get wrong warnings
       int cnt = usedItemCount();
       if(cnt) //Don't use qDebug, because that may not work during destruction
         std::cout << m_id.constData() << " There were items left on destruction: " << usedItemCount() << "\n";
 
       for (int a = 0; a < m_items.size(); ++a)
         delete m_items.at(a);
     }
 
-    inline T& getItem(int index) {
+    inline T& item(int index) {
       //For performance reasons this function does not lock the mutex, it's called too often and must be
       //extremely fast. There is special measures in alloc() to make this safe.
       Q_ASSERT(index & DynamicAppendedListMask);
 
       return *m_items.at(index & KDevelop::DynamicAppendedListRevertMask);
     }
 
-    ///Allocates an item index, which from now on you can get using getItem, until you call free(..) on the index.
+    ///Allocates an item index, which from now on you can get using item(), until you call free(..) on the index.
     ///The returned item is not initialized and may contain random older content, so you should clear it after getting it for the first time
     int alloc() {
 
       if(threadSafe)
         m_mutex.lock();
 
       int ret;
       if(!m_freeIndicesWithData.isEmpty()) {
         ret = m_freeIndicesWithData.pop();
       }else if(!m_freeIndices.isEmpty()) {
         ret = m_freeIndices.pop();
         Q_ASSERT(!m_items.at(ret));
         m_items[ret] = new T;
       }else{
         if(m_items.size() >= m_items.capacity()) {
           //We need to re-allocate
           const int newItemsSize = m_items.capacity() + 20 + (m_items.capacity()/3);
           const QVector<T*> oldItems = m_items; // backup
           m_items.reserve(newItemsSize); // detach, grow container
 
           const auto now = time(nullptr);
 
           // We do this in this place so it isn't called too often. The result is that we will always have some additional data around.
           // However the index itself should anyway not consume too much data.
           while (!m_deleteLater.isEmpty()) {
             // We delete only after 5 seconds
             if (now - m_deleteLater.first().first <= 5) {
               break;
             }
             m_deleteLater.removeFirst();
           }
 
-          //The only function that does not lock the mutex is getItem(..), because that function must be very efficient.
+          //The only function that does not lock the mutex is item(..), because that function must be very efficient.
           //Since it's only a few instructions from the moment m_items is read to the moment it's used,
           //deleting the old data after a few seconds should be safe.
           m_deleteLater.append(qMakePair(now, oldItems));
         }
 
         ret = m_items.size();
         m_items.append(new T);
         Q_ASSERT(m_items.size() <= m_items.capacity());
       }
 
       if(threadSafe)
         m_mutex.unlock();
 
       Q_ASSERT(!(ret & DynamicAppendedListMask));
 
       return ret | DynamicAppendedListMask;
     }
 
     void free(int index) {
       Q_ASSERT(index & DynamicAppendedListMask);
       index &= KDevelop::DynamicAppendedListRevertMask;
 
       if(threadSafe)
         m_mutex.lock();
 
       freeItem(m_items.at(index));
 
       m_freeIndicesWithData.push(index);
 
       //Hold the amount of free indices with data between 100 and 200
       if(m_freeIndicesWithData.size() > 200) {
         for(int a = 0; a < 100; ++a) {
           int deleteIndexData = m_freeIndicesWithData.pop();
           auto& item = m_items[deleteIndexData];
           delete item;
           item = nullptr;
           m_freeIndices.push(deleteIndexData);
         }
       }
 
       if(threadSafe)
         m_mutex.unlock();
     }
 
     int usedItemCount() const {
       int ret = 0;
       for(int a = 0; a < m_items.size(); ++a)
         if(m_items.at(a))
           ++ret;
       return ret - m_freeIndicesWithData.size();
     }
 
   private:
     //To save some memory, clear the lists
     void freeItem(T* item) {
       item->clear(); ///@todo make this a template specialization that only does this for containers
     }
 
     QVector<T*> m_items; /// note: non-shared, ref count of 1 when accessed with non-const methods => no detach
     Stack<int> m_freeIndicesWithData;
     Stack<int> m_freeIndices;
     QMutex m_mutex;
     QByteArray m_id;
     QList<QPair<time_t, QVector<T*> > > m_deleteLater;
 };
 
 ///Foreach macro that takes a container and a function-name, and will iterate through the vector returned by that function, using the length returned by the function-name with "Size" appended.
 //This might be a little slow
 #define FOREACH_FUNCTION(item, container) \
     for(uint a__ = 0, mustDo__ = 1, containerSize = container ## Size(); a__ < containerSize; ++a__) \
       if((mustDo__ == 0 || mustDo__ == 1) && (mustDo__ = 2)) \
         for(item(container()[a__]); mustDo__; mustDo__ = 0)
 
 #define DEFINE_LIST_MEMBER_HASH(container, member, type) \
     typedef KDevelop::TemporaryDataManager<KDevVarLengthArray<type, 10> > temporaryHash ## container ## member ## Type; \
     Q_GLOBAL_STATIC_WITH_ARGS(temporaryHash ## container ## member ## Type, temporaryHash ## container ## member ## Static, ( #container "::" #member )) \
     temporaryHash ## container ## member ## Type& temporaryHash ## container ## member() { \
         return *temporaryHash ## container ## member ## Static; \
     }
 
 #define DECLARE_LIST_MEMBER_HASH(container, member, type) \
     KDevelop::TemporaryDataManager<KDevVarLengthArray<type, 10> >& temporaryHash ## container ## member();
 
 ///This implements the interfaces so this container can be used as a predecessor for classes with appended lists.
 ///You should do this within the abstract base class that opens a tree of classes that can have appended lists,
 ///so each class that uses them, can also give its predecessor to START_APPENDE_LISTS, to increase flexibility.
 ///This  creates a boolean entry that is initialized when initializeAppendedLists is called.
 ///You can call appendedListsDynamic() to find out whether the item is marked as dynamic.
 ///When this item is used, the same rules have to be followed as for a class with appended lists: You have to call
 ///initializeAppendedLists(...) and freeAppendedLists(..)
 ///Also, when you use this, you have to implement a uint classSize() function, that returns the size of the class including derived classes,
 ///but not including the dynamic data. Optionally you can implement a static bool appendedListDynamicDefault() function, that returns the default-value for the "dynamic" parameter.
 ///to initializeAppendedLists.
 #define APPENDED_LISTS_STUB(container) \
     bool m_dynamic : 1;                          \
     unsigned int offsetBehindLastList() const { return 0; } \
     uint dynamicSize() const { return classSize(); } \
     template<class T> bool listsEqual(const T& /*rhs*/) const { return true; } \
     template<class T> void copyAllFrom(const T& /*rhs*/) const { } \
     void initializeAppendedLists(bool dynamic = appendedListDynamicDefault()) { m_dynamic = dynamic; }  \
     void freeAppendedLists() { } \
     bool appendedListsDynamic() const { return m_dynamic; }
 
 
 ///use this if the class does not have a base class that also uses appended lists
 #define START_APPENDED_LISTS(container) \
     unsigned int offsetBehindBase() const { return 0; } \
     void freeDynamicData() { freeAppendedLists(); }
 
 ///Use this if one of the base-classes of the container also has the appended lists interfaces implemented.
 ///To reduce the probability of future problems, you should give the direct base class this one inherits from.
 ///@note: Multiple inheritance is not supported, however it will work ok if only one of the base-classes uses appended lists.
 #define START_APPENDED_LISTS_BASE(container, base) \
     unsigned int offsetBehindBase() const { return base :: offsetBehindLastList(); } \
     void freeDynamicData() { freeAppendedLists(); base::freeDynamicData(); }
 
 
 #define APPENDED_LIST_COMMON(container, type, name) \
       uint name ## Data; \
-      unsigned int name ## Size() const { if((name ## Data & KDevelop::DynamicAppendedListRevertMask) == 0) return 0; if(!appendedListsDynamic()) return name ## Data; else return temporaryHash ## container ## name().getItem(name ## Data).size(); } \
-      KDevVarLengthArray<type, 10>& name ## List() { name ## NeedDynamicList(); return temporaryHash ## container ## name().getItem(name ## Data); }\
+      unsigned int name ## Size() const { if((name ## Data & KDevelop::DynamicAppendedListRevertMask) == 0) return 0; if(!appendedListsDynamic()) return name ## Data; else return temporaryHash ## container ## name().item(name ## Data).size(); } \
+      KDevVarLengthArray<type, 10>& name ## List() { name ## NeedDynamicList(); return temporaryHash ## container ## name().item(name ## Data); }\
       template<class T> bool name ## Equals(const T& rhs) const { unsigned int size = name ## Size(); if(size != rhs.name ## Size()) return false; for(uint a = 0; a < size; ++a) {if(!(name()[a] == rhs.name()[a])) return false;} return true;  } \
       template<class T> void name ## CopyFrom( const T& rhs ) { \
         if(rhs.name ## Size() == 0 && (name ## Data & KDevelop::DynamicAppendedListRevertMask) == 0) return; \
         if(appendedListsDynamic()) {  \
           name ## NeedDynamicList(); \
-          KDevVarLengthArray<type, 10>& item( temporaryHash ## container ## name().getItem(name ## Data) ); \
+          KDevVarLengthArray<type, 10>& item( temporaryHash ## container ## name().item(name ## Data) ); \
           item.clear();                    \
           const type* otherCurr = rhs.name(); \
           const type* otherEnd = otherCurr + rhs.name ## Size(); \
           for(; otherCurr < otherEnd; ++otherCurr) \
             item.append(*otherCurr); \
         }else{ \
           Q_ASSERT(name ## Data == 0); /* It is dangerous to overwrite the contents of non-dynamic lists(Most probably a mistake) */ \
           name ## Data = rhs.name ## Size(); \
           type* curr = const_cast<type*>(name());  type* end = curr + name ## Size(); \
           const type* otherCurr = rhs.name(); \
           for(; curr < end; ++curr, ++otherCurr) \
             new (curr) type(*otherCurr); /* Call the copy constructors */ \
         }\
       } \
       void name ## NeedDynamicList() { \
         Q_ASSERT(appendedListsDynamic()); \
         if((name ## Data & KDevelop::DynamicAppendedListRevertMask) == 0) {\
           name ## Data = temporaryHash ## container ## name().alloc();\
-          Q_ASSERT(temporaryHash ## container ## name().getItem(name ## Data).isEmpty()); \
+          Q_ASSERT(temporaryHash ## container ## name().item(name ## Data).isEmpty()); \
         } \
       } \
       void name ## Initialize(bool dynamic) { name ## Data = (dynamic ? KDevelop::DynamicAppendedListMask : 0); }  \
       void name ## Free() { \
         if(appendedListsDynamic()) { \
           if(name ## Data & KDevelop::DynamicAppendedListRevertMask) temporaryHash ## container ## name().free(name ## Data);\
         } else { \
           type* curr = const_cast<type*>(name()); \
           type* end = curr + name ## Size(); \
           for(; curr < end; ++curr) curr->~type(); /*call destructors*/ \
         } \
       }  \
 
 
 ///@todo Make these things a bit faster(less recursion)
 
 #define APPENDED_LIST_FIRST(container, type, name) \
     APPENDED_LIST_COMMON(container, type, name) \
     const type* name() const { \
       if((name ## Data & KDevelop::DynamicAppendedListRevertMask) == 0) return nullptr; \
       if(!appendedListsDynamic()) return reinterpret_cast<const type*>(reinterpret_cast<const char*>(this) + classSize() + offsetBehindBase()); \
-      else return temporaryHash ## container ## name().getItem(name ## Data).data(); \
+      else return temporaryHash ## container ## name().item(name ## Data).data(); \
     } \
     unsigned int name ## OffsetBehind() const { return name ## Size() * sizeof(type) + offsetBehindBase(); } \
     template<class T> bool name ## ListChainEquals( const T& rhs ) const { return name ## Equals(rhs); } \
     template<class T> void name ## CopyAllFrom( const T& rhs ) { name ## CopyFrom(rhs); } \
     void name ## InitializeChain(bool dynamic) { name ## Initialize(dynamic); }  \
     void name ## FreeChain() { name ## Free(); }
 
 #define APPENDED_LIST(container, type, name, predecessor) \
     APPENDED_LIST_COMMON(container, type, name) \
     const type* name() const {\
       if((name ## Data & KDevelop::DynamicAppendedListRevertMask) == 0) return nullptr; \
       if(!appendedListsDynamic()) return reinterpret_cast<const type*>(reinterpret_cast<const char*>(this) + classSize() + predecessor ## OffsetBehind()); \
-      else return temporaryHash ## container ## name().getItem(name ## Data).data(); \
+      else return temporaryHash ## container ## name().item(name ## Data).data(); \
     } \
     unsigned int name ## OffsetBehind() const { return name ## Size() * sizeof(type) + predecessor ## OffsetBehind(); } \
     template<class T> bool name ## ListChainEquals( const T& rhs ) const { return name ## Equals(rhs) && predecessor ## ListChainEquals(rhs); } \
     template<class T> void name ## CopyAllFrom( const T& rhs ) { predecessor ## CopyAllFrom(rhs); name ## CopyFrom(rhs); } \
     void name ## InitializeChain(bool dynamic) { name ## Initialize(dynamic); predecessor ## InitializeChain(dynamic);  }  \
     void name ## FreeChain() { name ## Free(); predecessor ## FreeChain(); }
 
 #define END_APPENDED_LISTS(container, predecessor) \
     /* Returns the size of the object containing the appended lists, including them */ \
     unsigned int completeSize() const { return classSize() + predecessor ## OffsetBehind(); } \
     /* Compares all local appended lists(not from base classes) and returns true if they are equal */                \
     template<class T> bool listsEqual(const T& rhs) const { return predecessor ## ListChainEquals(rhs); } \
     /* Copies all the local appended lists(not from base classes) from the given item.*/   \
     template<class T> void copyListsFrom(const T& rhs) { return predecessor ## CopyAllFrom(rhs); } \
     void initializeAppendedLists(bool dynamic = appendedListDynamicDefault()) { \
       predecessor ## Data = (dynamic ? KDevelop::DynamicAppendedListMask : 0); \
       predecessor ## InitializeChain(dynamic); \
     } \
     void freeAppendedLists() { predecessor ## FreeChain(); } \
     bool appendedListsDynamic() const { return predecessor ## Data & KDevelop::DynamicAppendedListMask; } \
     unsigned int offsetBehindLastList() const { return predecessor ## OffsetBehind(); } \
     uint dynamicSize() const { return offsetBehindLastList() + classSize(); }
 
 /**
  * This is a class that allows you easily putting instances of your class into an ItemRepository as seen in itemrepository.h.
  * All your class needs to do is:
  * - Be implemented using the APPENDED_LIST macros.
   * - Have a real copy-constructor that additionally takes a "bool dynamic = true" parameter, which should be given to initializeAppendedLists
  * - Except for these appended lists, only contain directly copyable data like indices(no pointers, no virtual functions)
  * - Implement operator==(..) which should compare everything, including the lists. @warning The default operator will not work!
  * - Implement a hash() function. The hash should equal for two instances when operator==(..) returns true.
  * - Should be completely functional without a constructor called, only the data copied
  * - Implement a "bool persistent() const" function, that should check the reference-count or other information to decide whether the item should stay in the repository
  * If those conditions are fulfilled, the data can easily be put into a repository using this request class.
  * */
 
 template<class Type, uint averageAppendedBytes = 8>
 class AppendedListItemRequest {
   public:
   AppendedListItemRequest(const Type& item) : m_item(item) {
   }
 
   enum {
     AverageSize = sizeof(Type) + averageAppendedBytes
   };
 
   unsigned int hash() const {
     return m_item.hash();
   }
 
   uint itemSize() const {
       return m_item.dynamicSize();
   }
 
   void createItem(Type* item) const {
     new (item) Type(m_item, false);
   }
   
   static void destroy(Type* item, KDevelop::AbstractItemRepository&) {
     item->~Type();
   }
   
   static bool persistent(const Type* item) {
     return item->persistent();
   }
 
   bool equals(const Type* item) const {
     return m_item == *item;
   }
 
   const Type& m_item;
 };
 }
 
 ///This function is outside of the namespace, so it can always be found. It's used as default-parameter to initializeAppendedLists(..),
 ///and you can for example implement a function called like this in your local class hierarchy to override this default.
 inline bool appendedListDynamicDefault() {
   return true;
 }
 
 #endif
diff --git a/kdevplatform/language/duchain/declaration.cpp b/kdevplatform/language/duchain/declaration.cpp
index ffd2926d4b..c443ff1c13 100644
--- a/kdevplatform/language/duchain/declaration.cpp
+++ b/kdevplatform/language/duchain/declaration.cpp
@@ -1,783 +1,783 @@
 /* This file is part of KDevelop
     Copyright 2006 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 "declaration.h"
 #include "declarationdata.h"
 
 #include <QByteArray>
 
 #include <limits>
 
 #include "topducontext.h"
 #include "topducontextdynamicdata.h"
 #include "use.h"
 #include "forwarddeclaration.h"
 #include "duchain.h"
 #include "duchainlock.h"
 #include "ducontextdata.h"
 #include "declarationid.h"
 #include "uses.h"
 #include <serialization/indexedstring.h>
 #include "duchainregister.h"
 #include "persistentsymboltable.h"
 #include "types/identifiedtype.h"
 #include "types/structuretype.h"
 #include "functiondefinition.h"
 #include "codemodel.h"
 #include "specializationstore.h"
 #include "types/typeutils.h"
 #include "types/typealiastype.h"
 #include "classdeclaration.h"
 #include "serialization/stringrepository.h"
 #include "ducontextdynamicdata.h"
 
 namespace KDevelop
 {
 
 REGISTER_DUCHAIN_ITEM(Declaration);
 
 DeclarationData::DeclarationData()
   : m_isDefinition(false)
   , m_inSymbolTable(false)
   , m_isTypeAlias(false)
   , m_anonymousInContext(false)
   , m_isDeprecated(false)
   , m_alwaysForceDirect(false)
   , m_isAutoDeclaration(false)
   , m_isExplicitlyDeleted(false)
   , m_isExplicitlyTyped(false)
 {
 }
 
 ///@todo Use reference counting
 static Repositories::StringRepository& commentRepository() {
     static Repositories::StringRepository commentRepositoryObject(QStringLiteral("Comment Repository"));
     return commentRepositoryObject;
 }
 
 void initDeclarationRepositories() {
   commentRepository();
 }
 
 Declaration::Kind Declaration::kind() const {
   DUCHAIN_D(Declaration);
   return d->m_kind;
 }
 
 void Declaration::setKind(Kind kind) {
   DUCHAIN_D_DYNAMIC(Declaration);
   d->m_kind = kind;
   updateCodeModel();
 }
 
 bool Declaration::inDUChain() const {
   DUCHAIN_D(Declaration);
   if( d->m_anonymousInContext )
     return false;
   if( !context() )
     return false;
   TopDUContext* top = topContext();
   return top && top->inDUChain();
 }
 
 Declaration::Declaration( const RangeInRevision& range, DUContext* context )
   : DUChainBase(*new DeclarationData, range)
 {
   d_func_dynamic()->setClassId(this);
   m_topContext = nullptr;
   m_context = nullptr;
   m_indexInTopContext = 0;
 
   if(context)
     setContext(context);
 }
 
 uint Declaration::ownIndex() const
 {
   ENSURE_CAN_READ
   return m_indexInTopContext;
 }
 
 Declaration::Declaration(const Declaration& rhs)
   : DUChainBase(*new DeclarationData( *rhs.d_func() ))
 {
 }
 
 Declaration::Declaration( DeclarationData & dd ) : DUChainBase(dd)
 {
 }
 
 Declaration::Declaration( DeclarationData & dd, const RangeInRevision& range )
   : DUChainBase(dd, range)
 {
 }
 
 bool Declaration::persistentlyDestroying() const
 {
   TopDUContext* topContext = this->topContext();
   return !topContext->deleting() || !topContext->isOnDisk();
 }
 
 Declaration::~Declaration()
 {
   uint oldOwnIndex = m_indexInTopContext;
 
   TopDUContext* topContext = this->topContext();
 
   //Only perform the actions when the top-context isn't being deleted, or when it hasn't been stored to disk
   if(persistentlyDestroying()) {
     DUCHAIN_D_DYNAMIC(Declaration);
 
     // Inserted by the builder after construction has finished.
     if( d->m_internalContext.context() )
       d->m_internalContext.context()->setOwner(nullptr);
 
     setInSymbolTable(false);
   }
 
   // If the parent-context already has dynamic data, like for example any temporary context,
   // always delete the declaration, to not create crashes within more complex code like C++ template stuff.
   if (context() && !d_func()->m_anonymousInContext) {
     if(!topContext->deleting() || !topContext->isOnDisk() || context()->d_func()->isDynamic())
       context()->m_dynamicData->removeDeclaration(this);
   }
 
   clearOwnIndex();
 
   if(!topContext->deleting() || !topContext->isOnDisk()) {
     setContext(nullptr);
 
     setAbstractType(AbstractType::Ptr());
   }
   Q_ASSERT(d_func()->isDynamic() == (!topContext->deleting() || !topContext->isOnDisk() || topContext->m_dynamicData->isTemporaryDeclarationIndex(oldOwnIndex)));
   Q_UNUSED(oldOwnIndex);
 }
 
 QByteArray Declaration::comment() const {
   DUCHAIN_D(Declaration);
   if(!d->m_comment)
     return nullptr;
   else
     return Repositories::arrayFromItem(commentRepository().itemFromIndex(d->m_comment));
 }
 
 void Declaration::setComment(const QByteArray& str) {
   DUCHAIN_D_DYNAMIC(Declaration);
   if(str.isEmpty())
     d->m_comment = 0;
   else
     d->m_comment = commentRepository().index(Repositories::StringRepositoryItemRequest(str.constData(), IndexedString::hashString(str.constData(), str.length()), str.length()));
 }
 
 void Declaration::setComment(const QString& str) {
   setComment(str.toUtf8());
 }
 
 Identifier Declaration::identifier( ) const
 {
   //ENSURE_CAN_READ Commented out for performance reasons
   return d_func()->m_identifier.identifier();
 }
 
 const IndexedIdentifier& Declaration::indexedIdentifier( ) const
 {
   //ENSURE_CAN_READ Commented out for performance reasons
   return d_func()->m_identifier;
 }
 
 void Declaration::rebuildDynamicData(DUContext* parent, uint ownIndex)
 {
   DUChainBase::rebuildDynamicData(parent, ownIndex);
 
   m_context = parent;
   m_topContext = parent->topContext();
   m_indexInTopContext = ownIndex;
 }
 
 void Declaration::setIdentifier(const Identifier& identifier)
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(Declaration);
   bool wasInSymbolTable = d->m_inSymbolTable;
 
   setInSymbolTable(false);
 
   d->m_identifier = identifier;
 
   setInSymbolTable(wasInSymbolTable);
 }
 
 IndexedType Declaration::indexedType() const
 {
   return d_func()->m_type;
 }
 
 AbstractType::Ptr Declaration::abstractType( ) const
 {
   //ENSURE_CAN_READ Commented out for performance reasons
   return d_func()->m_type.abstractType();
 }
 
 void Declaration::setAbstractType(AbstractType::Ptr type)
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(Declaration);
 
   d->m_type = type ? type->indexed() : IndexedType();
 
   updateCodeModel();
 }
 
 Declaration* Declaration::specialize(const IndexedInstantiationInformation& /*specialization*/, const TopDUContext* topContext, int /*upDistance*/)
 {
   if(!topContext)
     return nullptr;
   return this;
 }
 
 QualifiedIdentifier Declaration::qualifiedIdentifier() const
 {
   ENSURE_CAN_READ
 
   QualifiedIdentifier ret;
   DUContext* ctx = m_context;
   if(ctx)
     ret = ctx->scopeIdentifier(true);
   ret.push(d_func()->m_identifier);
   return ret;
 }
 
 DUContext * Declaration::context() const
 {
   //ENSURE_CAN_READ Commented out for performance reasons
   return m_context;
 }
 
 bool Declaration::isAnonymous() const
 {
   return d_func()->m_anonymousInContext;
 }
 
 void Declaration::setContext(DUContext* context, bool anonymous)
 {
   Q_ASSERT(!context || context->topContext());
 
   DUCHAIN_D_DYNAMIC(Declaration);
 
   if (context == m_context && anonymous == d->m_anonymousInContext) {
     // skip costly operations below when the same context is set
     // this happens often when updating a TopDUContext from the cache
     return;
   }
 
   setInSymbolTable(false);
 
   //We don't need to clear, because it's not allowed to move from one top-context into another
 //   clearOwnIndex();
 
   if (m_context && context) {
     Q_ASSERT(m_context->topContext() == context->topContext());
   }
 
   if (m_context) {
     if( !d->m_anonymousInContext ) {
       m_context->m_dynamicData->removeDeclaration(this);
     }
   }
 
   if(context)
     m_topContext = context->topContext();
   else
     m_topContext = nullptr;
 
   d->m_anonymousInContext = anonymous;
   m_context = context;
 
   if (context) {
     if(!m_indexInTopContext)
       allocateOwnIndex();
 
     if(!d->m_anonymousInContext) {
       context->m_dynamicData->addDeclaration(this);
     }
 
     if(context->inSymbolTable() && !anonymous)
       setInSymbolTable(true);
   }
 }
 
 void Declaration::clearOwnIndex() {
 
   if(!m_indexInTopContext)
     return;
 
   if(!context() || (!d_func()->m_anonymousInContext && !context()->isAnonymous())) {
     ENSURE_CAN_WRITE
   }
 
   if(m_indexInTopContext) {
     Q_ASSERT(m_topContext);
     m_topContext->m_dynamicData->clearDeclarationIndex(this);
   }
   m_indexInTopContext = 0;
 }
 
 void Declaration::allocateOwnIndex() {
 
   ///@todo Fix multithreading stuff with template instantiation, preferably using some internal mutexes
 //   if(context() && (!context()->isAnonymous() && !d_func()->m_anonymousInContext)) {
 //     ENSURE_CAN_WRITE
 //   }
 
   Q_ASSERT(m_topContext);
 
   m_indexInTopContext = m_topContext->m_dynamicData->allocateDeclarationIndex(this, d_func()->m_anonymousInContext || !context() || context()->isAnonymous());
   Q_ASSERT(m_indexInTopContext);
 
-  if(!m_topContext->m_dynamicData->getDeclarationForIndex(m_indexInTopContext))
+  if(!m_topContext->m_dynamicData->declarationForIndex(m_indexInTopContext))
     qFatal("Could not re-retrieve declaration\nindex: %d", m_indexInTopContext);
 
 }
 
 const Declaration* Declaration::logicalDeclaration(const TopDUContext* topContext) const {
   ENSURE_CAN_READ
   if(isForwardDeclaration()) {
     const auto dec = static_cast<const ForwardDeclaration*>(this);
     Declaration* ret = dec->resolve(topContext);
     if(ret)
       return ret;
   }
   return this;
 }
 
 Declaration* Declaration::logicalDeclaration(const TopDUContext* topContext) {
   ENSURE_CAN_READ
   if(isForwardDeclaration()) {
     const auto dec = static_cast<const ForwardDeclaration*>(this);
     Declaration* ret = dec->resolve(topContext);
     if(ret)
       return ret;
   }
   return this;
 }
 
 DUContext * Declaration::logicalInternalContext(const TopDUContext* topContext) const {
   ENSURE_CAN_READ
 
   if(!isDefinition()) {
     Declaration* def = FunctionDefinition::definition(this);
     if( def )
       return def->internalContext();
   }
 
   if( d_func()->m_isTypeAlias ) {
     ///If this is a type-alias, return the internal context of the actual type.
     TypeAliasType::Ptr t = type<TypeAliasType>();
     if(t) {
       AbstractType::Ptr target = t->type();
       
       IdentifiedType* idType = dynamic_cast<IdentifiedType*>(target.data());
       if( idType ) {
         Declaration* decl = idType->declaration(topContext);
         if(decl && decl != this) {
           return decl->logicalInternalContext( topContext );
         }
       }
     }
   }
 
   return internalContext();
 }
 
 DUContext * Declaration::internalContext() const
 {
 //   ENSURE_CAN_READ
   return d_func()->m_internalContext.context();
 }
 
 void Declaration::setInternalContext(DUContext* context)
 {
   if(this->context()) {
     ENSURE_CAN_WRITE
   }
   DUCHAIN_D_DYNAMIC(Declaration);
 
   if( context == d->m_internalContext.context() )
     return;
 
   if(!m_topContext) {
     //Take the top-context from the other side. We need to allocate an index, so we can safely call setOwner(..)
     m_topContext = context->topContext();
     allocateOwnIndex();
   }
 
   DUContext* oldInternalContext = d->m_internalContext.context();
 
   d->m_internalContext = context;
 
   //Q_ASSERT( !oldInternalContext || oldInternalContext->owner() == this );
   if( oldInternalContext && oldInternalContext->owner() == this )
     oldInternalContext->setOwner(nullptr);
 
 
   if( context )
     context->setOwner(this);
 }
 
 
 bool Declaration::operator ==(const Declaration & other) const
 {
   ENSURE_CAN_READ
 
   return this == &other;
 }
 
 QString Declaration::toString() const
 {
   return QStringLiteral("%3 %4").arg(abstractType() ? abstractType()->toString() : QStringLiteral("<notype>"), identifier().toString());
 }
 
 
 bool Declaration::isDefinition() const
 {
   ENSURE_CAN_READ
   DUCHAIN_D(Declaration);
 
   return d->m_isDefinition;
 }
 
 void Declaration::setDeclarationIsDefinition(bool dd)
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(Declaration);
   d->m_isDefinition = dd;
 //   if (d->m_isDefinition && definition()) {
 //     setDefinition(0);
 //   }
 }
 
 bool Declaration::isAutoDeclaration() const
 {
   return d_func()->m_isAutoDeclaration;
 }
 
 void Declaration::setAutoDeclaration(bool _auto)
 {
   d_func_dynamic()->m_isAutoDeclaration = _auto;
 }
 
 bool Declaration::isDeprecated() const
 {
   return d_func()->m_isDeprecated;
 }
 
 void Declaration::setDeprecated(bool deprecated)
 {
   d_func_dynamic()->m_isDeprecated = deprecated;
 }
 
 bool Declaration::alwaysForceDirect() const
 {
   return d_func()->m_alwaysForceDirect;
 }
 
 void Declaration::setAlwaysForceDirect(bool direct)
 {
   d_func_dynamic()->m_alwaysForceDirect = direct;
 }
 
 bool Declaration::isExplicitlyDeleted() const
 {
   return d_func()->m_isExplicitlyDeleted;
 }
 
 void Declaration::setExplicitlyDeleted(bool deleted)
 {
   d_func_dynamic()->m_isExplicitlyDeleted = deleted;
 }
 
 bool Declaration::isExplicitlyTyped() const
 {
   return d_func()->m_isExplicitlyTyped;
 }
 
 void Declaration::setExplicitlyTyped(bool explicitlyTyped)
 {
   d_func_dynamic()->m_isExplicitlyTyped = explicitlyTyped;
 }
 
 ///@todo see whether it would be useful to create an own TypeAliasDeclaration sub-class for this
 bool Declaration::isTypeAlias() const {
   DUCHAIN_D(Declaration);
   return d->m_isTypeAlias;
 }
 
 void Declaration::setIsTypeAlias(bool isTypeAlias) {
   DUCHAIN_D_DYNAMIC(Declaration);
   d->m_isTypeAlias = isTypeAlias;
 }
 
 IndexedInstantiationInformation Declaration::specialization() const {
   return IndexedInstantiationInformation();
 }
 
 void Declaration::activateSpecialization()
 {
   if(specialization().index()) {
     DeclarationId baseId(id());
     baseId.setSpecialization(IndexedInstantiationInformation());
     SpecializationStore::self().set(baseId, specialization());
   }
 }
 
 DeclarationId Declaration::id(bool forceDirect) const
 {
   ENSURE_CAN_READ
   if(inSymbolTable() && !forceDirect && !alwaysForceDirect())
     return DeclarationId(qualifiedIdentifier(), additionalIdentity(), specialization());
   else
     return DeclarationId(IndexedDeclaration(const_cast<Declaration*>(this)), specialization());
 }
 
 bool Declaration::inSymbolTable() const
 {
   DUCHAIN_D(Declaration);
   return d->m_inSymbolTable;
 }
 
 CodeModelItem::Kind kindForDeclaration(Declaration* decl) {
   CodeModelItem::Kind kind = CodeModelItem::Unknown;
 
   if(decl->kind() == Declaration::Namespace)
     return CodeModelItem::Namespace;
 
   if(decl->isFunctionDeclaration()) {
     kind = CodeModelItem::Function;
   }
 
   if(decl->kind() == Declaration::Type && (decl->type<StructureType>() || dynamic_cast<ClassDeclaration*>(decl)))
     kind = CodeModelItem::Class;
 
   if(kind == CodeModelItem::Unknown && decl->kind() == Declaration::Instance)
     kind = CodeModelItem::Variable;
 
   if(decl->isForwardDeclaration())
     kind = (CodeModelItem::Kind)(kind | CodeModelItem::ForwardDeclaration);
 
   if ( decl->context() && decl->context()->type() == DUContext::Class )
     kind = (CodeModelItem::Kind)(kind | CodeModelItem::ClassMember);
 
   return kind;
 }
 
 void Declaration::updateCodeModel()
 {
   DUCHAIN_D(Declaration);
   if(!d->m_identifier.isEmpty() && d->m_inSymbolTable) {
     QualifiedIdentifier id(qualifiedIdentifier());
     CodeModel::self().updateItem(url(), id, kindForDeclaration(this));
   }
 }
 
 void Declaration::setInSymbolTable(bool inSymbolTable)
 {
   DUCHAIN_D_DYNAMIC(Declaration);
   if(!d->m_identifier.isEmpty()) {
     if(!d->m_inSymbolTable && inSymbolTable) {
       QualifiedIdentifier id(qualifiedIdentifier());
       PersistentSymbolTable::self().addDeclaration(id, this);
 
       CodeModel::self().addItem(url(), id, kindForDeclaration(this));
     }
 
     else if(d->m_inSymbolTable && !inSymbolTable) {
       QualifiedIdentifier id(qualifiedIdentifier());
       PersistentSymbolTable::self().removeDeclaration(id, this);
 
       CodeModel::self().removeItem(url(), id);
     }
   }
   d->m_inSymbolTable = inSymbolTable;
 }
 
 TopDUContext * Declaration::topContext() const
 {
   return m_topContext;
 }
 
 Declaration* Declaration::clonePrivate() const  {
   return new Declaration(*this);
 }
 
 Declaration* Declaration::clone() const  {
   Declaration* ret = clonePrivate();
   ret->d_func_dynamic()->m_inSymbolTable = false;
   return ret;
 }
 
 bool Declaration::isForwardDeclaration() const
 {
   return false;
 }
 
 bool Declaration::isFunctionDeclaration() const
 {
   return false;
 }
 
 uint Declaration::additionalIdentity() const
 {
   return 0;
 }
 
 bool Declaration::equalQualifiedIdentifier(const Declaration* rhs) const {
   ENSURE_CAN_READ
   DUCHAIN_D(Declaration);
   if(d->m_identifier != rhs->d_func()->m_identifier)
     return false;
 
   return m_context->equalScopeIdentifier(m_context);
 }
 
 QMap<IndexedString, QVector<RangeInRevision> > Declaration::uses() const
 {
   ENSURE_CAN_READ
   QMap<IndexedString, QMap<RangeInRevision, bool> > tempUses;
 
   //First, search for uses within the own context
   {
     QMap<RangeInRevision, bool>& ranges(tempUses[topContext()->url()]);
     foreach(const RangeInRevision range, allUses(topContext(), const_cast<Declaration*>(this)))
       ranges[range] = true;
   }
 
   DeclarationId _id = id();
   KDevVarLengthArray<IndexedTopDUContext> useContexts = DUChain::uses()->uses(_id);
   if (!_id.isDirect())
   { // also check uses based on direct IDs
     KDevVarLengthArray<IndexedTopDUContext> directUseContexts = DUChain::uses()->uses(id(true));
     useContexts.append(directUseContexts.data(), directUseContexts.size());
   }
 
   foreach (const IndexedTopDUContext indexedContext, useContexts) {
     TopDUContext* context = indexedContext.data();
     if(context) {
       QMap<RangeInRevision, bool>& ranges(tempUses[context->url()]);
       foreach(const RangeInRevision range, allUses(context, const_cast<Declaration*>(this)))
         ranges[range] = true;
     }
   }
 
   QMap<IndexedString, QVector<RangeInRevision>> ret;
 
   for(QMap<IndexedString, QMap<RangeInRevision, bool> >::const_iterator it = tempUses.constBegin(); it != tempUses.constEnd(); ++it) {
     if(!(*it).isEmpty()) {
       auto& list = ret[it.key()];
       list.reserve((*it).size());
       for(QMap<RangeInRevision, bool>::const_iterator it2 = (*it).constBegin(); it2 != (*it).constEnd(); ++it2)
         list << it2.key();
     }
   }
   return ret;
 }
 
 bool hasDeclarationUse(DUContext* context, int declIdx)
 {
   bool ret=false;
   int usescount=context->usesCount();
   const Use* uses=context->uses();
   
   for(int i=0; !ret && i<usescount; ++i) {
     ret = uses[i].m_declarationIndex==declIdx;
   }
   
   foreach(DUContext* child, context->childContexts()) {
     ret = ret || hasDeclarationUse(child, declIdx);
     if(ret)
       break;
   }
   
   return ret;
 }
 
 bool Declaration::hasUses() const
 {
   ENSURE_CAN_READ
   int idx = topContext()->indexForUsedDeclaration(const_cast<Declaration*>(this), false);
   bool ret = idx != std::numeric_limits<int>::max() && (idx>=0 || hasDeclarationUse(topContext(), idx)); //hasLocalUses
   DeclarationId myId = id();
 
   if (!ret && DUChain::uses()->hasUses(myId))
   {
     ret = true;
   }
 
   if (!ret && !myId.isDirect() && DUChain::uses()->hasUses(id(true)))
   {
     ret = true;
   }
 
   return ret;
 }
 
 QMap<IndexedString, QVector<KTextEditor::Range>> Declaration::usesCurrentRevision() const
 {
   ENSURE_CAN_READ
   QMap<IndexedString, QMap<KTextEditor::Range, bool> > tempUses;
 
   //First, search for uses within the own context
   {
     QMap<KTextEditor::Range, bool>& ranges(tempUses[topContext()->url()]);
     foreach(const RangeInRevision range, allUses(topContext(), const_cast<Declaration*>(this)))
     {
       ranges[topContext()->transformFromLocalRevision(range)] = true;
     }
   }
 
   DeclarationId _id = id();
   KDevVarLengthArray<IndexedTopDUContext> useContexts = DUChain::uses()->uses(_id);
   if (!_id.isDirect())
   { // also check uses based on direct IDs
     KDevVarLengthArray<IndexedTopDUContext> directUseContexts = DUChain::uses()->uses(id(true));
     useContexts.append(directUseContexts.data(), directUseContexts.size());
   }
 
   foreach (const IndexedTopDUContext indexedContext, useContexts) {
     TopDUContext* context = indexedContext.data();
     if(context) {
       QMap<KTextEditor::Range, bool>& ranges(tempUses[context->url()]);
       foreach(const RangeInRevision range, allUses(context, const_cast<Declaration*>(this)))
         ranges[context->transformFromLocalRevision(range)] = true;
     }
   }
 
   QMap<IndexedString, QVector<KTextEditor::Range>> ret;
 
   for(QMap<IndexedString, QMap<KTextEditor::Range, bool> >::const_iterator it = tempUses.constBegin(); it != tempUses.constEnd(); ++it) {
     if(!(*it).isEmpty()) {
       auto& list = ret[it.key()];
       list.reserve((*it).size());
       for(QMap<KTextEditor::Range, bool>::const_iterator it2 = (*it).constBegin(); it2 != (*it).constEnd(); ++it2)
         list << it2.key();
     }
   }
   return ret;
 }
 
 }
diff --git a/kdevplatform/language/duchain/declarationid.cpp b/kdevplatform/language/duchain/declarationid.cpp
index a52cc0cced..fbb6cc3b3e 100644
--- a/kdevplatform/language/duchain/declarationid.cpp
+++ b/kdevplatform/language/duchain/declarationid.cpp
@@ -1,239 +1,239 @@
 /* This file is part of KDevelop
     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 "declarationid.h"
 
 #include "ducontext.h"
 #include "topducontext.h"
 #include "duchain.h"
 #include "declaration.h"
 #include "persistentsymboltable.h"
 #include "instantiationinformation.h"
 
 #include <util/convenientfreelist.h>
 
 namespace KDevelop {
 
 DeclarationId::DeclarationId(const IndexedQualifiedIdentifier& id, uint additionalId,
                              const IndexedInstantiationInformation& specialization)
   : m_indirectData{id, additionalId}
   , m_isDirect(false)
   , m_specialization(specialization)
 {
 }
 
 DeclarationId::DeclarationId(const IndexedDeclaration& decl,
                              const IndexedInstantiationInformation& specialization)
   : m_directData(decl)
   , m_isDirect(true)
   , m_specialization(specialization)
 {
 }
 
 DeclarationId::DeclarationId(const DeclarationId& rhs)
   : m_isDirect(rhs.m_isDirect)
   , m_specialization(rhs.m_specialization)
 {
   if (!m_isDirect) {
     // IndexedQualifiedIdentifier doesn't like zero-initialization...
     new (&m_indirectData.identifier) IndexedQualifiedIdentifier(rhs.m_indirectData.identifier);
     m_indirectData.additionalIdentity = rhs.m_indirectData.additionalIdentity;
   } else {
     m_directData = rhs.m_directData;
   }
 }
 
 DeclarationId::~DeclarationId()
 {
   if (!m_isDirect) {
     m_indirectData.~Indirect();
   }
 }
 
 DeclarationId& DeclarationId::operator=(const DeclarationId& rhs)
 {
   if (&rhs == this)
     return *this;
 
   m_isDirect = rhs.m_isDirect;
   m_specialization = rhs.m_specialization;
   if (!m_isDirect) {
     m_indirectData = rhs.m_indirectData;
   } else {
     m_directData = rhs.m_directData;
   }
   return *this;
 }
 
 bool DeclarationId::isDirect() const
 {
   return m_isDirect;
 }
 
 void DeclarationId::setSpecialization(const IndexedInstantiationInformation& spec)
 {
   m_specialization = spec;
 }
 
 IndexedInstantiationInformation DeclarationId::specialization() const
 {
   return m_specialization;
 }
 
-KDevVarLengthArray<Declaration*> DeclarationId::getDeclarations(const TopDUContext* top) const
+KDevVarLengthArray<Declaration*> DeclarationId::declarations(const TopDUContext* top) const
 {
   KDevVarLengthArray<Declaration*> ret;
 
   if(m_isDirect == false) {
     //Find the declaration by its qualified identifier and additionalIdentity
     QualifiedIdentifier id(m_indirectData.identifier);
 
     if(top) {
       //Do filtering
       PersistentSymbolTable::FilteredDeclarationIterator filter =
-          PersistentSymbolTable::self().getFilteredDeclarations(id, top->recursiveImportIndices());
+          PersistentSymbolTable::self().filteredDeclarations(id, top->recursiveImportIndices());
       for(; filter; ++filter) {
           Declaration* decl = filter->data();
           if(decl && m_indirectData.additionalIdentity == decl->additionalIdentity()) {
             //Hit
             ret.append(decl);
           }
       }
     }else{
       //Just accept anything
-      PersistentSymbolTable::Declarations decls = PersistentSymbolTable::self().getDeclarations(id);
+      PersistentSymbolTable::Declarations decls = PersistentSymbolTable::self().declarations(id);
       PersistentSymbolTable::Declarations::Iterator decl = decls.iterator();
       for(; decl; ++decl) {
         const IndexedDeclaration& iDecl(*decl);
 
           ///@todo think this over once we don't pull in all imported top-context any more
         //Don't trigger loading of top-contexts from here, it will create a lot of problems
         if((!DUChain::self()->isInMemory(iDecl.topContextIndex())))
           continue;
 
         Declaration* decl = iDecl.data();
         if(decl && m_indirectData.additionalIdentity == decl->additionalIdentity()) {
           //Hit
           ret.append(decl);
         }
       }
     }
   }else{
     Declaration* decl = m_directData.declaration();
     if(decl)
       ret.append(decl);
   }
 
   if(!ret.isEmpty() && m_specialization.index()) {
     KDevVarLengthArray<Declaration*> newRet;
     foreach (Declaration* decl, ret) {
         Declaration* specialized = decl->specialize(m_specialization, top ? top : decl->topContext());
         if(specialized)
           newRet.append(specialized);
     }
     return newRet;
   }
   return ret;
 }
 
-Declaration* DeclarationId::getDeclaration(const TopDUContext* top, bool instantiateIfRequired) const
+Declaration* DeclarationId::declaration(const TopDUContext* top, bool instantiateIfRequired) const
 {
   Declaration* ret = nullptr;
 
   if(m_isDirect == false) {
     //Find the declaration by its qualified identifier and additionalIdentity
     QualifiedIdentifier id(m_indirectData.identifier);
 
     if(top) {
       //Do filtering
       PersistentSymbolTable::FilteredDeclarationIterator filter =
-          PersistentSymbolTable::self().getFilteredDeclarations(id, top->recursiveImportIndices());
+          PersistentSymbolTable::self().filteredDeclarations(id, top->recursiveImportIndices());
       for(; filter; ++filter) {
           Declaration* decl = filter->data();
           if(decl && m_indirectData.additionalIdentity == decl->additionalIdentity()) {
             //Hit
             ret = decl;
             if(!ret->isForwardDeclaration())
               break;
           }
       }
     }else{
       //Just accept anything
-      PersistentSymbolTable::Declarations decls = PersistentSymbolTable::self().getDeclarations(id);
+      PersistentSymbolTable::Declarations decls = PersistentSymbolTable::self().declarations(id);
       PersistentSymbolTable::Declarations::Iterator decl = decls.iterator();
       for(; decl; ++decl) {
         const IndexedDeclaration& iDecl(*decl);
 
         ///@todo think this over once we don't pull in all imported top-context any more
         //Don't trigger loading of top-contexts from here, it will create a lot of problems
         if((!DUChain::self()->isInMemory(iDecl.topContextIndex())))
           continue;
 
         Declaration* decl = iDecl.data();
         if(decl && m_indirectData.additionalIdentity == decl->additionalIdentity()) {
           //Hit
           ret = decl;
           if(!ret->isForwardDeclaration())
             break;
         }
       }
     }
   }else{
     //Find the declaration by m_topContext and m_declaration
     ret = m_directData.declaration();
   }
 
 
   if(ret)
   {
     if(m_specialization.isValid())
     {
       const TopDUContext* topContextForSpecialization = top;
       if(!instantiateIfRequired)
         topContextForSpecialization = nullptr; //If we don't want to instantiate new declarations, set the top-context to zero, so specialize(..) will only look-up
       else if(!topContextForSpecialization)
         topContextForSpecialization = ret->topContext();
 
       return ret->specialize(m_specialization, topContextForSpecialization);
     }else{
       return ret;
     }
   }else
     return nullptr;
 }
 
 QualifiedIdentifier DeclarationId::qualifiedIdentifier() const
 {
 
   if(!m_isDirect) {
     QualifiedIdentifier baseIdentifier = m_indirectData.identifier.identifier();
     if(!m_specialization.index())
       return baseIdentifier;
     return m_specialization.information().applyToIdentifier(baseIdentifier);
   } else {
-    Declaration* decl = getDeclaration(nullptr);
+    Declaration* decl = declaration(nullptr);
     if(decl)
       return decl->qualifiedIdentifier();
 
     return QualifiedIdentifier(i18n("(unknown direct declaration)"));
   }
 
   return QualifiedIdentifier(i18n("(missing)")) + m_indirectData.identifier.identifier();
 }
 
 }
diff --git a/kdevplatform/language/duchain/declarationid.h b/kdevplatform/language/duchain/declarationid.h
index e5c72e2ed7..d086dbe2e9 100644
--- a/kdevplatform/language/duchain/declarationid.h
+++ b/kdevplatform/language/duchain/declarationid.h
@@ -1,208 +1,208 @@
 /* This file is part of KDevelop
     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 KDEVPLATFORM_DECLARATION_ID_H
 #define KDEVPLATFORM_DECLARATION_ID_H
 
 #include "indexeddeclaration.h"
 #include "identifier.h"
 #include "instantiationinformation.h"
 #include <language/util/kdevhash.h>
 
 //krazy:excludeall=dpointer
 
 namespace KDevelop {
 
 class Declaration;
 class TopDUContext;
 
 /**
  * \short Allows clearly identifying a Declaration.
  *
  * DeclarationId is needed to uniquely address Declarations that are in another top-context,
  * because there may be multiple parsed versions of a file.
  *
  * There are two forms of DeclarationId, one indirect and one direct.  The direct form
  * holds a reference to the Declaration instance, whereas the indirect form stores the qualified
  * identifier and an additional index to disambiguate instances of multiple declarations with the same
  * identifier.
  *
  * Both forms also have a specialization index. It can be used in a language-specific way to pick other
  * versions of the declaration. When the declaration is found, Declaration::specialize() is called on
  * the found declaration with this value, and the returned value is the actually found declaration.
  *
  * \note This only works when the Declaration is in the symbol table.
  * */
 class KDEVPLATFORMLANGUAGE_EXPORT DeclarationId {
   public:
     /**
      * Constructor for indirect access to a declaration.  The resulting DeclarationId will not
      * have a direct reference to the Declaration, but will look it up as needed.
      *
      * \param id Identifier for this declaration id.
      * \param additionalId Additional index to disambiguate
      * \param specialization Specialization index (see class documentation).
      */
     explicit DeclarationId(const IndexedQualifiedIdentifier& id = IndexedQualifiedIdentifier(),
                   uint additionalId = 0,
                   const IndexedInstantiationInformation& specialization = IndexedInstantiationInformation());
 
     /**
      * Constructor for direct access to a declaration.  The resulting DeclarationId will
      * directly reference the Declaration
      *
      * \param decl Declaration to reference.
      * \param specialization Specialization index (see class documentation).
      */
     explicit DeclarationId(const IndexedDeclaration& decl,
                            const IndexedInstantiationInformation& specialization = IndexedInstantiationInformation());
 
 
     DeclarationId(const DeclarationId& rhs);
 
     ~DeclarationId();
 
     DeclarationId& operator=(const DeclarationId& rhs);
 
     /**
      * Equality operator.
      *
      * \param rhs declaration identifier to compare.
      * \returns true if equal, otherwise false.
      */
     bool operator==(const DeclarationId& rhs) const {
       if(m_isDirect != rhs.m_isDirect)
         return false;
 
       if(!m_isDirect)
         return m_indirectData.identifier == rhs.m_indirectData.identifier
           && m_indirectData.additionalIdentity == rhs.m_indirectData.additionalIdentity
           && m_specialization == rhs.m_specialization;
       else
         return m_directData == rhs.m_directData && m_specialization == rhs.m_specialization;
     }
 
     /**
      * Not equal operator.
      *
      * \param rhs declaration identifier to compare.
      * \returns true if not equal, otherwise false.
      */
     bool operator!=(const DeclarationId& rhs) const {
       return !operator==(rhs);
     }
 
     /**
      * Determine whether this declaration identifier references a valid declaration.
      */
     bool isValid() const {
       return (m_isDirect && m_directData.isValid()) || m_indirectData.identifier.isValid();
     }
 
     /**
      * Hash function for this declaration identifier.
      *
      * \warning This may return different hashes for the same declaration,
      *          depending on whether the id is direct or indirect,
      *          and thus you cannot compare hashes for declaration equality (use operator==() instead)
      */
     uint hash() const {
       if(m_isDirect)
         return KDevHash() << m_directData.hash() << m_specialization.index();
       else
-        return KDevHash() << m_indirectData.identifier.getIndex() << m_indirectData.additionalIdentity << m_specialization.index();
+        return KDevHash() << m_indirectData.identifier.index() << m_indirectData.additionalIdentity << m_specialization.index();
     }
 
     /**
      * Retrieve the declaration, from the perspective of \a context.
      * In order to be retrievable, the declaration must be in the symbol table.
      *
      * \param context Context in which to search for the Declaration.
      * \param instantiateIfRequired Whether the declaration should be instantiated if required
      * \returns the referenced Declaration, or null if none was found.
      * */
-    Declaration* getDeclaration(const TopDUContext* context, bool instantiateIfRequired = true) const;
+    Declaration* declaration(const TopDUContext* context, bool instantiateIfRequired = true) const;
 
     /**
-     * Same as getDeclaration(..), but returns all matching declarations if there are multiple.
+     * Same as declaration(..), but returns all matching declarations if there are multiple.
      * This also returns found forward-declarations.
      */
-    KDevVarLengthArray<Declaration*> getDeclarations(const TopDUContext* context) const;
+    KDevVarLengthArray<Declaration*> declarations(const TopDUContext* context) const;
 
     /**
      * Set the specialization index (see class documentation).
      *
      * \param spec the new specialization index.
      */
     void setSpecialization(const IndexedInstantiationInformation& spec);
 
     /**
      * Retrieve the specialization index (see class documentation).
      *
      * \returns the specialization index.
      */
     IndexedInstantiationInformation specialization() const;
 
     /**
      * Determine whether this DeclarationId directly references a Declaration by indices,
      * or if it uses identifiers and other data to reference the Declaration.
      *
      * \returns true if direct, false if indirect.
      */
     bool isDirect() const;
 
     /**
      * Return the qualified identifier for this declaration.
      *
      * \warning This is relatively expensive, and not 100% correct in all cases(actually a top-context would be needed to resolve this correctly),
      *          so avoid using this, except for debugging purposes.
      */
     QualifiedIdentifier qualifiedIdentifier() const;
 
   private:
     /// An indirect reference to the declaration, which uses the symbol-table for lookup. Should be preferred for all
     /// declarations that are in the symbol-table
     struct Indirect {
       IndexedQualifiedIdentifier identifier;
       /// Hash from signature, or similar. Used to disambiguate multiple declarations of the same name.
       uint additionalIdentity;
 
       Indirect& operator=(const Indirect& rhs) = default;
     };
 
     union {
       Indirect m_indirectData;
       IndexedDeclaration m_directData;
     };
     bool m_isDirect;
 
     // Can be used in a language-specific way to pick other versions of the declaration.
     // When the declaration is found, pickSpecialization is called on the found declaration
     // with this value, and the returned value is the actually found declaration.
     IndexedInstantiationInformation m_specialization;
 };
 
 inline uint qHash(const KDevelop::DeclarationId& id) {
   return id.hash();
 }
 
 }
 
 Q_DECLARE_TYPEINFO(KDevelop::DeclarationId, Q_MOVABLE_TYPE);
 
 #endif
diff --git a/kdevplatform/language/duchain/duchainutils.cpp b/kdevplatform/language/duchain/duchainutils.cpp
index ebc0a8c8c6..05dc4ca11f 100644
--- a/kdevplatform/language/duchain/duchainutils.cpp
+++ b/kdevplatform/language/duchain/duchainutils.cpp
@@ -1,626 +1,626 @@
 /*
  * DUChain Utilities
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2007-2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "duchainutils.h"
 
 #include <algorithm>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 
 #include "../interfaces/ilanguagesupport.h"
 #include "../assistant/staticassistantsmanager.h"
 #include <debug.h>
 
 #include "declaration.h"
 #include "classfunctiondeclaration.h"
 #include "ducontext.h"
 #include "duchain.h"
 #include "use.h"
 #include "duchainlock.h"
 #include "classmemberdeclaration.h"
 #include "functiondefinition.h"
 #include "specializationstore.h"
 #include "persistentsymboltable.h"
 #include "classdeclaration.h"
 #include "parsingenvironment.h"
 
 #include <QStandardPaths>
 
 using namespace KDevelop;
 using namespace KTextEditor;
 
 CodeCompletionModel::CompletionProperties DUChainUtils::completionProperties(const Declaration* dec)
 {
   CodeCompletionModel::CompletionProperties p;
 
   if(dec->context()->type() == DUContext::Class) {
     if (const ClassMemberDeclaration* member = dynamic_cast<const ClassMemberDeclaration*>(dec)) {
       switch (member->accessPolicy()) {
         case Declaration::Public:
           p |= CodeCompletionModel::Public;
           break;
         case Declaration::Protected:
           p |= CodeCompletionModel::Protected;
           break;
         case Declaration::Private:
           p |= CodeCompletionModel::Private;
           break;
         default:
           break;
       }
 
       if (member->isStatic())
         p |= CodeCompletionModel::Static;
       if (member->isAuto())
         {}//TODO
       if (member->isFriend())
         p |= CodeCompletionModel::Friend;
       if (member->isRegister())
         {}//TODO
       if (member->isExtern())
         {}//TODO
       if (member->isMutable())
         {}//TODO
     }
   }
 
   if (const AbstractFunctionDeclaration* function = dynamic_cast<const AbstractFunctionDeclaration*>(dec)) {
     p |= CodeCompletionModel::Function;
     if (function->isVirtual())
       p |= CodeCompletionModel::Virtual;
     if (function->isInline())
       p |= CodeCompletionModel::Inline;
     if (function->isExplicit())
       {}//TODO
   }
 
   if( dec->isTypeAlias() )
     p |= CodeCompletionModel::TypeAlias;
 
   if (dec->abstractType()) {
     switch (dec->abstractType()->whichType()) {
       case AbstractType::TypeIntegral:
         p |= CodeCompletionModel::Variable;
         break;
       case AbstractType::TypePointer:
         p |= CodeCompletionModel::Variable;
         break;
       case AbstractType::TypeReference:
         p |= CodeCompletionModel::Variable;
         break;
       case AbstractType::TypeFunction:
         p |= CodeCompletionModel::Function;
         break;
       case AbstractType::TypeStructure:
         p |= CodeCompletionModel::Class;
         break;
       case AbstractType::TypeArray:
         p |= CodeCompletionModel::Variable;
         break;
       case AbstractType::TypeEnumeration:
         p |= CodeCompletionModel::Enum;
         break;
       case AbstractType::TypeEnumerator:
         p |= CodeCompletionModel::Variable;
         break;
       case AbstractType::TypeAbstract:
       case AbstractType::TypeDelayed:
       case AbstractType::TypeUnsure:
       case AbstractType::TypeAlias:
         // TODO
         break;
     }
 
     if( dec->abstractType()->modifiers() & AbstractType::ConstModifier )
       p |= CodeCompletionModel::Const;
 
     if( dec->kind() == Declaration::Instance && !dec->isFunctionDeclaration() )
       p |= CodeCompletionModel::Variable;
   }
 
   if (dec->context()) {
     if( dec->context()->type() == DUContext::Global )
       p |= CodeCompletionModel::GlobalScope;
     else if( dec->context()->type() == DUContext::Namespace )
       p |= CodeCompletionModel::NamespaceScope;
     else if( dec->context()->type() != DUContext::Class && dec->context()->type() != DUContext::Enum )
       p |= CodeCompletionModel::LocalScope;
   }
 
   return p;
 }
 /**We have to construct the item from the pixmap, else the icon will be marked as "load on demand",
  * and for some reason will be loaded every time it's used(this function returns a QIcon marked "load on demand"
  * each time this is called). And the loading is very slow. Seems like a bug somewhere, it cannot be ment to be that slow.
  */
 #define RETURN_CACHED_ICON(name) {static QIcon icon(QIcon( \
       QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kdevelop/pics/" name ".png"))\
     ).pixmap(QSize(16, 16)));\
     return icon;}
 
 QIcon DUChainUtils::iconForProperties(KTextEditor::CodeCompletionModel::CompletionProperties p)
 {
 
   if( (p & CodeCompletionModel::Variable) )
     if( (p & CodeCompletionModel::Protected) )
       RETURN_CACHED_ICON("CVprotected_var")
     else if( p & CodeCompletionModel::Private )
       RETURN_CACHED_ICON("CVprivate_var")
     else
       RETURN_CACHED_ICON("CVpublic_var")
   else
   if( (p & CodeCompletionModel::Union) && (p & CodeCompletionModel::Protected) )
     RETURN_CACHED_ICON("protected_union")
 
   else if( p & CodeCompletionModel::Enum )
     if( p & CodeCompletionModel::Protected )
       RETURN_CACHED_ICON("protected_enum")
     else if( p & CodeCompletionModel::Private )
       RETURN_CACHED_ICON("private_enum")
     else
       RETURN_CACHED_ICON("enum")
 
   else if( p & CodeCompletionModel::Struct )
     if( p & CodeCompletionModel::Private )
       RETURN_CACHED_ICON("private_struct")
     else
       RETURN_CACHED_ICON("struct")
 
   else if( p & CodeCompletionModel::Slot )
     if( p & CodeCompletionModel::Protected )
       RETURN_CACHED_ICON("CVprotected_slot")
     else if( p & CodeCompletionModel::Private )
       RETURN_CACHED_ICON("CVprivate_slot")
     else if(p & CodeCompletionModel::Public )
       RETURN_CACHED_ICON("CVpublic_slot")
     else RETURN_CACHED_ICON("slot")
   else if( p & CodeCompletionModel::Signal )
     if( p & CodeCompletionModel::Protected )
       RETURN_CACHED_ICON("CVprotected_signal")
     else
       RETURN_CACHED_ICON("signal")
 
   else if( p & CodeCompletionModel::Class )
     if( (p & CodeCompletionModel::Class) && (p & CodeCompletionModel::Protected) )
       RETURN_CACHED_ICON("protected_class")
     else if( (p & CodeCompletionModel::Class) && (p & CodeCompletionModel::Private) )
       RETURN_CACHED_ICON("private_class")
     else
       RETURN_CACHED_ICON("code-class")
 
   else if( p & CodeCompletionModel::Union )
     if( p & CodeCompletionModel::Private )
       RETURN_CACHED_ICON("private_union")
     else
       RETURN_CACHED_ICON("union")
 
   else if( p & CodeCompletionModel::TypeAlias )
     if ((p & CodeCompletionModel::Const) /*||  (p & CodeCompletionModel::Volatile)*/)
       RETURN_CACHED_ICON("CVtypedef")
     else
       RETURN_CACHED_ICON("typedef")
 
   else if( p & CodeCompletionModel::Function ) {
     if( p & CodeCompletionModel::Protected )
       RETURN_CACHED_ICON("protected_function")
     else if( p & CodeCompletionModel::Private )
       RETURN_CACHED_ICON("private_function")
     else
       RETURN_CACHED_ICON("code-function")
   }
 
   if( p & CodeCompletionModel::Protected )
     RETURN_CACHED_ICON("protected_field")
   else if( p & CodeCompletionModel::Private )
     RETURN_CACHED_ICON("private_field")
   else
     RETURN_CACHED_ICON("field")
 
   return QIcon();
 }
 
 QIcon DUChainUtils::iconForDeclaration(const Declaration* dec)
 {
   return iconForProperties(completionProperties(dec));
 }
 
 TopDUContext* DUChainUtils::contentContextFromProxyContext(TopDUContext* top)
 {
   if(!top)
     return nullptr;
   if(top->parsingEnvironmentFile() && top->parsingEnvironmentFile()->isProxyContext()) {
     if(!top->importedParentContexts().isEmpty())
     {
       DUContext* ctx = top->importedParentContexts().at(0).context(nullptr);
       if(!ctx)
         return nullptr;
       TopDUContext* ret = ctx->topContext();
       if(!ret)
         return nullptr;
       if(ret->url() != top->url())
         qCDebug(LANGUAGE) << "url-mismatch between content and proxy:" << top->url().toUrl() << ret->url().toUrl();
       if(ret->url() == top->url() && !ret->parsingEnvironmentFile()->isProxyContext())
         return ret;
     }
     else {
       qCDebug(LANGUAGE) << "Proxy-context imports no content-context";
     }
   } else
     return top;
   return nullptr;
 }
 
 TopDUContext* DUChainUtils::standardContextForUrl(const QUrl& url, bool preferProxyContext) {
   KDevelop::TopDUContext* chosen = nullptr;
 
   const auto languages = ICore::self()->languageController()->languagesForUrl(url);
 
   for (const auto language : languages) {
     if(!chosen)
     {
       chosen = language->standardContext(url, preferProxyContext);
     }
   }
 
   if(!chosen)
     chosen = DUChain::self()->chainForDocument(IndexedString(url), preferProxyContext);
 
   if(!chosen && preferProxyContext)
     return standardContextForUrl(url, false); // Fall back to a normal context
 
   return chosen;
 }
 
 struct ItemUnderCursorInternal
 {
   Declaration* declaration;
   DUContext* context;
   RangeInRevision range;
 };
 
 ItemUnderCursorInternal itemUnderCursorInternal(const CursorInRevision& c, DUContext* ctx, RangeInRevision::ContainsBehavior behavior)
 {
   //Search all collapsed sub-contexts. In C++, those can contain declarations that have ranges out of the context
   foreach(DUContext* subCtx, ctx->childContexts()) {
     //This is a little hacky, but we need it in case of foreach macros and similar stuff
     if(subCtx->range().contains(c, behavior) || subCtx->range().isEmpty() || subCtx->range().start.line == c.line || subCtx->range().end.line == c.line) {
       ItemUnderCursorInternal sub = itemUnderCursorInternal(c, subCtx, behavior);
       if(sub.declaration) {
         return sub;
       }
     }
   }
 
   foreach(Declaration* decl, ctx->localDeclarations()) {
     if(decl->range().contains(c, behavior)) {
       return {decl, ctx, decl->range()};
     }
   }
 
   //Try finding a use under the cursor
   for(int a = 0; a < ctx->usesCount(); ++a) {
     if(ctx->uses()[a].m_range.contains(c, behavior)) {
       return {ctx->topContext()->usedDeclarationForIndex(ctx->uses()[a].m_declarationIndex), ctx, ctx->uses()[a].m_range};
     }
   }
 
   return {nullptr, nullptr, RangeInRevision()};
 }
 
 DUChainUtils::ItemUnderCursor DUChainUtils::itemUnderCursor(const QUrl& url, const KTextEditor::Cursor& cursor)
 {
   KDevelop::TopDUContext* top = standardContextForUrl(url.adjusted(QUrl::NormalizePathSegments));
 
   if(!top) {
     return {nullptr, nullptr, KTextEditor::Range()};
   }
 
   ItemUnderCursorInternal decl = itemUnderCursorInternal(top->transformToLocalRevision(cursor), top, RangeInRevision::Default);
   if (decl.declaration == nullptr)
   {
     decl = itemUnderCursorInternal(top->transformToLocalRevision(cursor), top, RangeInRevision::IncludeBackEdge);
   }
   return {decl.declaration, decl.context, top->transformFromLocalRevision(decl.range)};
 }
 
 Declaration* DUChainUtils::declarationForDefinition(Declaration* definition, TopDUContext* topContext)
 {
   if(!definition)
     return nullptr;
 
   if(!topContext)
     topContext = definition->topContext();
 
   if(dynamic_cast<FunctionDefinition*>(definition)) {
     Declaration* ret = static_cast<FunctionDefinition*>(definition)->declaration();
     if(ret)
       return ret;
   }
 
   return definition;
 }
 
 Declaration* DUChainUtils::declarationInLine(const KTextEditor::Cursor& _cursor, DUContext* ctx) {
   if(!ctx)
     return nullptr;
 
   CursorInRevision cursor = ctx->transformToLocalRevision(_cursor);
 
   foreach(Declaration* decl, ctx->localDeclarations()) {
     if(decl->range().start.line == cursor.line)
       return decl;
-    DUContext* funCtx = getFunctionContext(decl);
+    DUContext* funCtx = functionContext(decl);
     if(funCtx && funCtx->range().contains(cursor))
       return decl;
   }
 
   foreach(DUContext* child, ctx->childContexts()){
     Declaration* decl = declarationInLine(_cursor, child);
     if(decl)
       return decl;
   }
 
   return nullptr;
 }
 
 DUChainUtils::DUChainItemFilter::~DUChainItemFilter() {
 }
 
 void DUChainUtils::collectItems( DUContext* context, DUChainItemFilter& filter ) {
 
   QVector<DUContext*> children = context->childContexts();
   QVector<Declaration*> localDeclarations = context->localDeclarations();
 
   QVector<DUContext*>::const_iterator childIt = children.constBegin();
   QVector<Declaration*>::const_iterator declIt = localDeclarations.constBegin();
 
   while(childIt != children.constEnd() || declIt != localDeclarations.constEnd()) {
 
     DUContext* child = nullptr;
     if(childIt != children.constEnd())
       child = *childIt;
 
     Declaration* decl = nullptr;
     if(declIt != localDeclarations.constEnd())
       decl = *declIt;
 
     if(decl) {
       if(child && child->range().start.line >= decl->range().start.line)
         child = nullptr;
     }
 
     if(child) {
       if(decl && decl->range().start >= child->range().start)
         decl = nullptr;
     }
 
     if(decl) {
       if( filter.accept(decl) ) {
         //Action is done in the filter
       }
 
       ++declIt;
       continue;
     }
 
     if(child) {
       if( filter.accept(child) )
         collectItems(child, filter);
       ++childIt;
       continue;
     }
   }
 }
 
-KDevelop::DUContext* DUChainUtils::getArgumentContext(KDevelop::Declaration* decl) {
+KDevelop::DUContext* DUChainUtils::argumentContext(KDevelop::Declaration* decl) {
   DUContext* internal = decl->internalContext();
   if( !internal )
     return nullptr;
   if( internal->type() == DUContext::Function )
     return internal;
   foreach( const DUContext::Import &ctx, internal->importedParentContexts() ) {
     if( ctx.context(decl->topContext()) )
       if( ctx.context(decl->topContext())->type() == DUContext::Function )
         return ctx.context(decl->topContext());
   }
   return nullptr;
 }
 
 QList<IndexedDeclaration> DUChainUtils::collectAllVersions(Declaration* decl) {
   QList<IndexedDeclaration> ret;
   ret << IndexedDeclaration(decl);
 
   if(decl->inSymbolTable())
   {
     uint count;
     const IndexedDeclaration* allDeclarations;
     PersistentSymbolTable::self().declarations(decl->qualifiedIdentifier(), count, allDeclarations);
     for(uint a = 0; a < count; ++a)
       if(!(allDeclarations[a] == IndexedDeclaration(decl)))
         ret << allDeclarations[a];
   }
 
   return ret;
 }
 
-static QList<Declaration*> getInheritersInternal(const Declaration* decl, uint& maxAllowedSteps, bool collectVersions)
+static QList<Declaration*> inheritersInternal(const Declaration* decl, uint& maxAllowedSteps, bool collectVersions)
 {
   QList<Declaration*> ret;
 
   if(!dynamic_cast<const ClassDeclaration*>(decl))
     return ret;
 
   if(maxAllowedSteps == 0)
     return ret;
 
   if(decl->internalContext() && decl->internalContext()->type() == DUContext::Class) {
     foreach (const IndexedDUContext importer, decl->internalContext()->indexedImporters()) {
 
       DUContext* imp = importer.data();
 
       if(!imp)
         continue;
 
       if(imp->type() == DUContext::Class && imp->owner())
         ret << imp->owner();
 
       --maxAllowedSteps;
 
       if(maxAllowedSteps == 0)
         return ret;
     }
   }
 
   if(collectVersions && decl->inSymbolTable()) {
     uint count;
     const IndexedDeclaration* allDeclarations;
     PersistentSymbolTable::self().declarations(decl->qualifiedIdentifier(), count, allDeclarations);
     for(uint a = 0; a < count; ++a) {
       ++maxAllowedSteps;
 
       if(allDeclarations[a].data() && allDeclarations[a].data() != decl) {
-        ret += getInheritersInternal(allDeclarations[a].data(), maxAllowedSteps, false);
+        ret += inheritersInternal(allDeclarations[a].data(), maxAllowedSteps, false);
       }
 
       if(maxAllowedSteps == 0)
         return ret;
     }
   }
 
   return ret;
 }
 
-QList<Declaration*> DUChainUtils::getInheriters(const Declaration* decl, uint& maxAllowedSteps, bool collectVersions)
+QList<Declaration*> DUChainUtils::inheriters(const Declaration* decl, uint& maxAllowedSteps, bool collectVersions)
 {
-  auto inheriters = getInheritersInternal(decl, maxAllowedSteps, collectVersions);
+  auto inheriters = inheritersInternal(decl, maxAllowedSteps, collectVersions);
 
   // remove duplicates
   std::sort(inheriters.begin(), inheriters.end());
   inheriters.erase(std::unique(inheriters.begin(), inheriters.end()), inheriters.end());
 
   return inheriters;
 }
 
-QList<Declaration*> DUChainUtils::getOverriders(const Declaration* currentClass, const Declaration* overriddenDeclaration, uint& maxAllowedSteps) {
+QList<Declaration*> DUChainUtils::overriders(const Declaration* currentClass, const Declaration* overriddenDeclaration, uint& maxAllowedSteps) {
   QList<Declaration*> ret;
 
   if(maxAllowedSteps == 0)
     return ret;
 
   if(currentClass != overriddenDeclaration->context()->owner() && currentClass->internalContext())
     ret += currentClass->internalContext()->findLocalDeclarations(overriddenDeclaration->identifier(), CursorInRevision::invalid(), currentClass->topContext(), overriddenDeclaration->abstractType());
 
-  foreach(Declaration* inheriter, getInheriters(currentClass, maxAllowedSteps))
-    ret += getOverriders(inheriter, overriddenDeclaration, maxAllowedSteps);
+  foreach(Declaration* inheriter, inheriters(currentClass, maxAllowedSteps))
+    ret += overriders(inheriter, overriddenDeclaration, maxAllowedSteps);
 
   return ret;
 }
 
 static bool hasUse(DUContext* context, int usedDeclarationIndex) {
   if(usedDeclarationIndex == std::numeric_limits<int>::max())
     return false;
 
   for(int a = 0; a < context->usesCount(); ++a)
     if(context->uses()[a].m_declarationIndex == usedDeclarationIndex)
       return true;
 
   foreach(DUContext* child, context->childContexts())
     if(hasUse(child, usedDeclarationIndex))
       return true;
   return false;
 }
 
 bool DUChainUtils::contextHasUse(DUContext* context, Declaration* declaration) {
   return hasUse(context, context->topContext()->indexForUsedDeclaration(declaration, false));
 }
 
 static uint countUses(DUContext* context, int usedDeclarationIndex) {
   if(usedDeclarationIndex == std::numeric_limits<int>::max())
     return 0;
 
   uint ret = 0;
 
   for(int a = 0; a < context->usesCount(); ++a)
     if(context->uses()[a].m_declarationIndex == usedDeclarationIndex)
       ++ret;
 
   foreach(DUContext* child, context->childContexts())
     ret += countUses(child, usedDeclarationIndex);
 
   return ret;
 }
 
 uint DUChainUtils::contextCountUses(DUContext* context, Declaration* declaration) {
   return countUses(context, context->topContext()->indexForUsedDeclaration(declaration, false));
 }
 
-Declaration* DUChainUtils::getOverridden(const Declaration* decl) {
+Declaration* DUChainUtils::overridden(const Declaration* decl) {
   const ClassFunctionDeclaration* classFunDecl = dynamic_cast<const ClassFunctionDeclaration*>(decl);
   if(!classFunDecl || !classFunDecl->isVirtual())
     return nullptr;
 
   QList<Declaration*> decls;
 
   foreach(const DUContext::Import &import, decl->context()->importedParentContexts()) {
     DUContext* ctx = import.context(decl->topContext());
     if(ctx)
       decls += ctx->findDeclarations(QualifiedIdentifier(decl->identifier()),
                                             CursorInRevision::invalid(), decl->abstractType(), decl->topContext(), DUContext::DontSearchInParent);
   }
 
   foreach(Declaration* found, decls) {
     const ClassFunctionDeclaration* foundClassFunDecl = dynamic_cast<const ClassFunctionDeclaration*>(found);
     if(foundClassFunDecl && foundClassFunDecl->isVirtual())
       return found;
   }
 
   return nullptr;
 }
 
-DUContext* DUChainUtils::getFunctionContext(Declaration* decl) {
+DUContext* DUChainUtils::functionContext(Declaration* decl) {
   DUContext* functionContext = decl->internalContext();
   if(functionContext && functionContext->type() != DUContext::Function) {
     foreach(const DUContext::Import& import, functionContext->importedParentContexts()) {
       DUContext* ctx = import.context(decl->topContext());
       if(ctx && ctx->type() == DUContext::Function)
         functionContext = ctx;
     }
   }
 
   if(functionContext && functionContext->type() == DUContext::Function)
     return functionContext;
   return nullptr;
 }
 
 QVector<KDevelop::Problem::Ptr> KDevelop::DUChainUtils::allProblemsForContext(const KDevelop::ReferencedTopDUContext& top)
 {
   QVector<KDevelop::Problem::Ptr> ret;
   Q_FOREACH ( const auto& p, top->problems() ) {
     ret << p;
   }
   Q_FOREACH ( const auto& p, ICore::self()->languageController()->staticAssistantsManager()->problemsForContext(top) ) {
     ret << p;
   }
   return ret;
 }
 
diff --git a/kdevplatform/language/duchain/duchainutils.h b/kdevplatform/language/duchain/duchainutils.h
index b68d6e3f83..5d6d15471f 100644
--- a/kdevplatform/language/duchain/duchainutils.h
+++ b/kdevplatform/language/duchain/duchainutils.h
@@ -1,132 +1,132 @@
 /*
  * DUChain Utilities
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2007-2009 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_DUCHAINUTILS_H
 #define KDEVPLATFORM_DUCHAINUTILS_H
 
 #include <QUrl>
 
 #include <language/languageexport.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/topducontext.h>
 
 #include <KTextEditor/CodeCompletionModel>
 
 class QIcon;
 
 namespace KTextEditor {
 class Cursor;
 }
 
 namespace KDevelop {
 
 class Declaration;
 class DUChainBase;
 class DUContext;
 class IndexedString;
 class TopDUContext;
 class IndexedDeclaration;
 
 /**
  * A namespace which contains convenience utilities for navigating definition-use chains.
  */
 namespace DUChainUtils {
   KDEVPLATFORMLANGUAGE_EXPORT KTextEditor::CodeCompletionModel::CompletionProperties completionProperties(const Declaration* dec);
   KDEVPLATFORMLANGUAGE_EXPORT QIcon iconForProperties(KTextEditor::CodeCompletionModel::CompletionProperties p);
   KDEVPLATFORMLANGUAGE_EXPORT QIcon iconForDeclaration(const Declaration* dec);
   /** Asks the language-plugins for standard-contexts for the given url, and returns one if available.
     * If there is no language-plugin registered for the given url, it will just try to get any top-context for the file from the du-chain.
     * NOTE: The DUChain needs to be read or write locked when you call this.
     * @param preferProxyContext Whether the returned context should be a proxy context. When no proxy-context is found, a normal context is returned.
     *
     * FIXME: this should operate on IndexedString
     */
   KDEVPLATFORMLANGUAGE_EXPORT KDevelop::TopDUContext* standardContextForUrl(const QUrl& url, bool preferProxyContext = false);
   /**
    * Returns the content-context associated to the given proxy-contex.
    * Returns the same context if it is not a proxy-context.
    * Returns zero if no content-context could be acquired.
    * */
   KDEVPLATFORMLANGUAGE_EXPORT TopDUContext* contentContextFromProxyContext(TopDUContext* top);
   struct KDEVPLATFORMLANGUAGE_EXPORT ItemUnderCursor {
     Declaration* declaration; // found declaration (either declared/defined or used)
     DUContext* context; // context in which the declaration, definition, or use was found
     KTextEditor::Range range; // range of the declaration/definition/use
   };
   /** Returns 1. the Declaration/Definition either declared or used under the cursor,
    * or zero; and 2. the context in which the declaration, definition, or use was found.
    * DUChain must be locked.
    * Must only be called from the foreground or with the foreground lock held. */
   KDEVPLATFORMLANGUAGE_EXPORT ItemUnderCursor itemUnderCursor(const QUrl& url, const KTextEditor::Cursor& cursor);
   /**If the given declaration is a definition, and has a real declaration
     *attached, returns that declarations. Else returns the given argument. */
   KDEVPLATFORMLANGUAGE_EXPORT Declaration* declarationForDefinition(Declaration* definition, TopDUContext* topContext = nullptr);
   ///Returns the first declaration in the given line. Searches the given context and all sub-contexts.
   ///Must only be called from the foreground or with the foreground lock held.
   KDEVPLATFORMLANGUAGE_EXPORT Declaration* declarationInLine(const KTextEditor::Cursor& cursor, KDevelop::DUContext* ctx);
 
   class KDEVPLATFORMLANGUAGE_EXPORT DUChainItemFilter {
     public:
     virtual bool accept(Declaration* decl) = 0;
     //Should return whether processing should be deepened into the given context
     virtual bool accept(DUContext* ctx) = 0;
     virtual ~DUChainItemFilter();
   };
   ///walks a context, all its sub-contexts, and all its declarations in exactly the order they appear in in the file.
   ///Re-implement DUChainItemFilter to do something with the items.
   KDEVPLATFORMLANGUAGE_EXPORT void collectItems( DUContext* context, DUChainItemFilter& filter );
 
-  KDEVPLATFORMLANGUAGE_EXPORT DUContext* getArgumentContext(Declaration* decl);
+  KDEVPLATFORMLANGUAGE_EXPORT DUContext* argumentContext(Declaration* decl);
 
   ///Uses the persistent symbol table to find all occurrences of this declaration, based on its identifier.
   ///The result should be filtered to make sure that the declaration is actually useful to you.
   KDEVPLATFORMLANGUAGE_EXPORT QList<IndexedDeclaration> collectAllVersions(Declaration* decl);
 
   ///If the given declaration is a class, this gets all classes that inherit this one
   ///@param collectVersions If this is true, the persistent symbol table is used to first find all registered
   ///                       versions of this class, and then get the inheriters from them all together. This is needed for C++.
   ///@param maxAllowedSteps The maximum of steps allowed. If this is zero in the end, this means the search has been stopped with the max. reached
   ///                                           If you really want _all_ inheriters, you should initialize it with a very large value.
-  KDEVPLATFORMLANGUAGE_EXPORT QList<Declaration*> getInheriters(const Declaration* decl, uint& maxAllowedSteps, bool collectVersions = true);
+  KDEVPLATFORMLANGUAGE_EXPORT QList<Declaration*> inheriters(const Declaration* decl, uint& maxAllowedSteps, bool collectVersions = true);
 
   ///Gets all functions that override the function @p overriddenDeclaration, starting the search at @p currentClass
   ///@param maxAllowedSteps The maximum of steps allowed. If this is zero in the end, this means the search has been stopped with the max. reached
-  KDEVPLATFORMLANGUAGE_EXPORT QList<Declaration*> getOverriders(const Declaration* currentClass, const Declaration* overriddenDeclaration, uint& maxAllowedSteps);
+  KDEVPLATFORMLANGUAGE_EXPORT QList<Declaration*> overriders(const Declaration* currentClass, const Declaration* overriddenDeclaration, uint& maxAllowedSteps);
 
   ///Returns whether the given context or any of its child-contexts contain a use of the given declaration. This is relatively expensive.
   KDEVPLATFORMLANGUAGE_EXPORT bool contextHasUse(DUContext* context, Declaration* declaration);
 
   ///Returns the total count of uses of the given declaration under the given context
   KDEVPLATFORMLANGUAGE_EXPORT uint contextCountUses(DUContext* context, Declaration* declaration);
 
   ///Returns the declaration that is overridden by the given one, or zero.
-  KDEVPLATFORMLANGUAGE_EXPORT Declaration* getOverridden(const Declaration* decl);
+  KDEVPLATFORMLANGUAGE_EXPORT Declaration* overridden(const Declaration* decl);
 
   ///If the given declaration is a function-declaration, this follows the context-structure up to the function-context that contains the arguments,
   ///and returns it.
-  KDEVPLATFORMLANGUAGE_EXPORT DUContext* getFunctionContext(Declaration* decl);
+  KDEVPLATFORMLANGUAGE_EXPORT DUContext* functionContext(Declaration* decl);
 
   KDEVPLATFORMLANGUAGE_EXPORT QVector<KDevelop::Problem::Ptr> allProblemsForContext(const ReferencedTopDUContext& top);
 }
 }
 
 #endif // KDEVPLATFORM_DUCHAINUTILS_H
diff --git a/kdevplatform/language/duchain/ducontext.cpp b/kdevplatform/language/duchain/ducontext.cpp
index c2b972f047..784cd7a347 100644
--- a/kdevplatform/language/duchain/ducontext.cpp
+++ b/kdevplatform/language/duchain/ducontext.cpp
@@ -1,1708 +1,1708 @@
 /* This  is part of KDevelop
     Copyright 2006 Hamish Rodda <rodda@kde.org>
     Copyright 2007-2009 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 "ducontext.h"
 
 #include <limits>
 #include <algorithm>
 
 #include <QSet>
 
 #include "ducontextdata.h"
 #include "declaration.h"
 #include "duchain.h"
 #include "duchainlock.h"
 #include "use.h"
 #include "identifier.h"
 #include "topducontext.h"
 #include "persistentsymboltable.h"
 #include "aliasdeclaration.h"
 #include "namespacealiasdeclaration.h"
 #include "abstractfunctiondeclaration.h"
 #include "duchainregister.h"
 #include "topducontextdynamicdata.h"
 #include "importers.h"
 #include "uses.h"
 #include "navigation/abstractdeclarationnavigationcontext.h"
 #include "navigation/abstractnavigationwidget.h"
 #include "ducontextdynamicdata.h"
 #include <debug.h>
 
 // maximum depth for DUContext::findDeclarationsInternal searches
 const uint maxParentDepth = 20;
 
 using namespace KTextEditor;
 
 #ifndef NDEBUG
 #define ENSURE_CAN_WRITE_(x) {if(x->inDUChain()) { ENSURE_CHAIN_WRITE_LOCKED }}
 #define ENSURE_CAN_READ_(x) {if(x->inDUChain()) { ENSURE_CHAIN_READ_LOCKED }}
 #else
 #define ENSURE_CAN_WRITE_(x)
 #define ENSURE_CAN_READ_(x)
 #endif
 
 QDebug operator<<(QDebug dbg, const KDevelop::DUContext::Import& import)
 {
   QDebugStateSaver saver(dbg);
   dbg.nospace() << "Import(" << import.indexedContext().data() << ')';
   return dbg;
 }
 
 namespace KDevelop
 {
 DEFINE_LIST_MEMBER_HASH(DUContextData, m_childContexts, LocalIndexedDUContext)
 DEFINE_LIST_MEMBER_HASH(DUContextData, m_importers, IndexedDUContext)
 DEFINE_LIST_MEMBER_HASH(DUContextData, m_importedContexts, DUContext::Import)
 DEFINE_LIST_MEMBER_HASH(DUContextData, m_localDeclarations, LocalIndexedDeclaration)
 DEFINE_LIST_MEMBER_HASH(DUContextData, m_uses, Use)
 
 REGISTER_DUCHAIN_ITEM(DUContext);
 
 DUChainVisitor::~DUChainVisitor()
 {
 }
 
 /**
  * We leak here, to prevent a possible crash during destruction, as the destructor
  * of Identifier is not safe to be called after the duchain has been destroyed
  */
 const Identifier& globalImportIdentifier() {
   static const Identifier globalImportIdentifierObject(QStringLiteral("{...import...}"));
   return globalImportIdentifierObject;
 }
 
 const Identifier& globalAliasIdentifier() {
   static const Identifier globalAliasIdentifierObject(QStringLiteral("{...alias...}"));
   return globalAliasIdentifierObject;
 }
 
 const IndexedIdentifier& globalIndexedImportIdentifier()
 {
   static const IndexedIdentifier id(globalImportIdentifier());
   return id;
 }
 
 const IndexedIdentifier& globalIndexedAliasIdentifier()
 {
   static const IndexedIdentifier id(globalAliasIdentifier());
   return id;
 }
 
 void DUContext::rebuildDynamicData(DUContext* parent, uint ownIndex) {
 
   Q_ASSERT(!parent || ownIndex);
   m_dynamicData->m_topContext = parent ? parent->topContext() : static_cast<TopDUContext*>(this);
   m_dynamicData->m_indexInTopContext = ownIndex;
   m_dynamicData->m_parentContext = DUContextPointer(parent);
   m_dynamicData->m_context = this;
 
   m_dynamicData->m_childContexts.clear();
   m_dynamicData->m_childContexts.reserve(d_func()->m_childContextsSize());
   FOREACH_FUNCTION(const LocalIndexedDUContext& ctx, d_func()->m_childContexts) {
     m_dynamicData->m_childContexts << ctx.data(m_dynamicData->m_topContext);
   }
 
   m_dynamicData->m_localDeclarations.clear();
   m_dynamicData->m_localDeclarations.reserve(d_func()->m_localDeclarationsSize());
   FOREACH_FUNCTION(const LocalIndexedDeclaration& idx, d_func()->m_localDeclarations) {
     auto declaration = idx.data(m_dynamicData->m_topContext);
     if (!declaration) {
       qCWarning(LANGUAGE) << "child declaration number" << idx.localIndex() << "of" << d_func_dynamic()->m_localDeclarationsSize() << "is invalid";
       continue;
     }
     m_dynamicData->m_localDeclarations << declaration;
   }
 
   DUChainBase::rebuildDynamicData(parent, ownIndex);
 }
 
 DUContextData::DUContextData()
   : m_inSymbolTable(false)
   , m_anonymousInParent(false)
   , m_propagateDeclarations(false)
 {
   initializeAppendedLists();
 }
 
 DUContextData::~DUContextData() {
   freeAppendedLists();
 }
 
 DUContextData::DUContextData(const DUContextData& rhs)
   : DUChainBaseData(rhs)
   , m_inSymbolTable(rhs.m_inSymbolTable)
   , m_anonymousInParent(rhs.m_anonymousInParent)
   , m_propagateDeclarations(rhs.m_propagateDeclarations)
 {
   initializeAppendedLists();
   copyListsFrom(rhs);
   m_scopeIdentifier = rhs.m_scopeIdentifier;
   m_contextType = rhs.m_contextType;
   m_owner = rhs.m_owner;
 }
 
 DUContextDynamicData::DUContextDynamicData(DUContext* d)
   : m_topContext(nullptr)
   , m_indexInTopContext(0)
   , m_context(d)
 {
 }
 
 void DUContextDynamicData::scopeIdentifier(bool includeClasses, QualifiedIdentifier& target) const {
   if (m_parentContext)
     m_parentContext->m_dynamicData->scopeIdentifier(includeClasses, target);
 
   if (includeClasses || d_func()->m_contextType != DUContext::Class)
     target += d_func()->m_scopeIdentifier;
 }
 
 bool DUContextDynamicData::imports(const DUContext* context, const TopDUContext* source,
                                    QSet<const DUContextDynamicData*>* recursionGuard) const
 {
   if( this == context->m_dynamicData )
     return true;
 
   if (recursionGuard->contains(this)) {
     return false;
   }
   recursionGuard->insert(this);
 
   FOREACH_FUNCTION( const DUContext::Import& ctx, d_func()->m_importedContexts ) {
     DUContext* import = ctx.context(source);
     if(import == context || (import && import->m_dynamicData->imports(context, source, recursionGuard)))
       return true;
   }
 
   return false;
 }
 
 inline bool isContextTemporary(uint index) {
   return index > (0xffffffff/2);
 }
 
 void DUContextDynamicData::addDeclaration( Declaration * newDeclaration )
 {
   // The definition may not have its identifier set when it's assigned...
   // allow dupes here, TODO catch the error elsewhere
 
   //If this context is temporary, added declarations should be as well, and viceversa
   Q_ASSERT(isContextTemporary(m_indexInTopContext) == isContextTemporary(newDeclaration->ownIndex()));
 
   CursorInRevision start = newDeclaration->range().start;
 
   bool inserted = false;
   ///@todo Do binary search to find the position
   for (int i = m_localDeclarations.size() - 1; i >= 0; --i) {
     Declaration* child = m_localDeclarations[i];
     Q_ASSERT(d_func()->m_localDeclarations()[i].data(m_topContext) == child);
     if(child == newDeclaration)
       return;
     //TODO: All declarations in a macro will have the same empty range, and just get appended
     //that may not be Good Enough in complex cases.
     if (start >= child->range().start) {
       m_localDeclarations.insert(i + 1, newDeclaration);
       d_func_dynamic()->m_localDeclarationsList().insert(i+1, newDeclaration);
       Q_ASSERT(d_func()->m_localDeclarations()[i+1].data(m_topContext) == newDeclaration);
 
       inserted = true;
       break;
     }
   }
 
   if (!inserted) {
     // We haven't found any child that is before this one, so prepend it
     m_localDeclarations.insert(0, newDeclaration);
     d_func_dynamic()->m_localDeclarationsList().insert(0, newDeclaration);
     Q_ASSERT(d_func()->m_localDeclarations()[0].data(m_topContext) == newDeclaration);
   }
 }
 
 bool DUContextDynamicData::removeDeclaration(Declaration* declaration)
 {
   const int idx = m_localDeclarations.indexOf(declaration);
   if (idx != -1) {
     Q_ASSERT(d_func()->m_localDeclarations()[idx].data(m_topContext) == declaration);
     m_localDeclarations.remove(idx);
     d_func_dynamic()->m_localDeclarationsList().remove(idx);
     return true;
   } else {
     Q_ASSERT(d_func_dynamic()->m_localDeclarationsList().indexOf(LocalIndexedDeclaration(declaration)) == -1);
     return false;
   }
 }
 
 void DUContextDynamicData::addChildContext( DUContext * context )
 {
   // Internal, don't need to assert a lock
   Q_ASSERT(!context->m_dynamicData->m_parentContext
            || context->m_dynamicData->m_parentContext.data()->m_dynamicData == this );
 
   LocalIndexedDUContext indexed(context->m_dynamicData->m_indexInTopContext);
 
   //If this context is temporary, added declarations should be as well, and viceversa
   Q_ASSERT(isContextTemporary(m_indexInTopContext) == isContextTemporary(indexed.localIndex()));
 
   bool inserted = false;
 
   int childCount = m_childContexts.size();
 
   for (int i = childCount-1; i >= 0; --i) {///@todo Do binary search to find the position
     DUContext* child = m_childContexts[i];
     Q_ASSERT(d_func_dynamic()->m_childContexts()[i] == LocalIndexedDUContext(child));
     if (context == child)
       return;
     if (context->range().start >= child->range().start) {
       m_childContexts.insert(i+1, context);
       d_func_dynamic()->m_childContextsList().insert(i+1, indexed);
       context->m_dynamicData->m_parentContext = m_context;
       inserted = true;
       break;
     }
   }
 
   if( !inserted ) {
     m_childContexts.insert(0, context);
     d_func_dynamic()->m_childContextsList().insert(0, indexed);
     context->m_dynamicData->m_parentContext = m_context;
   }
 }
 
 bool DUContextDynamicData::removeChildContext( DUContext* context ) {
 //   ENSURE_CAN_WRITE
 
   const int idx = m_childContexts.indexOf(context);
   if (idx != -1) {
     m_childContexts.remove(idx);
     Q_ASSERT(d_func()->m_childContexts()[idx] == LocalIndexedDUContext(context));
     d_func_dynamic()->m_childContextsList().remove(idx);
     return true;
   } else {
     Q_ASSERT(d_func_dynamic()->m_childContextsList().indexOf(LocalIndexedDUContext(context)) == -1);
     return false;
   }
 }
 
 void DUContextDynamicData::addImportedChildContext( DUContext * context )
 {
 //   ENSURE_CAN_WRITE
   DUContext::Import import(m_context, context);
 
   if(import.isDirect()) {
     //Direct importers are registered directly within the data
     if(d_func_dynamic()->m_importersList().contains(IndexedDUContext(context))) {
       qCDebug(LANGUAGE) << m_context->scopeIdentifier(true).toString() << "importer added multiple times:" << context->scopeIdentifier(true).toString();
       return;
     }
 
     d_func_dynamic()->m_importersList().append(context);
   }else{
     //Indirect importers are registered separately
     Importers::self().addImporter(import.indirectDeclarationId(), IndexedDUContext(context));
   }
 }
 
 //Can also be called with a context that is not in the list
 void DUContextDynamicData::removeImportedChildContext( DUContext * context )
 {
 //   ENSURE_CAN_WRITE
   DUContext::Import import(m_context, context);
 
   if(import.isDirect()) {
     d_func_dynamic()->m_importersList().removeOne(IndexedDUContext(context));
   }else{
     //Indirect importers are registered separately
     Importers::self().removeImporter(import.indirectDeclarationId(), IndexedDUContext(context));
   }
 }
 
 int DUContext::depth() const
 {
   { if (!parentContext()) return 0; return parentContext()->depth() + 1; }
 }
 
 DUContext::DUContext(DUContextData& data)
   : DUChainBase(data)
   , m_dynamicData(new DUContextDynamicData(this))
 {
 }
 
 
 DUContext::DUContext(const RangeInRevision& range, DUContext* parent, bool anonymous)
   : DUChainBase(*new DUContextData(), range)
   , m_dynamicData(new DUContextDynamicData(this))
 {
   d_func_dynamic()->setClassId(this);
   if(parent)
     m_dynamicData->m_topContext = parent->topContext();
   else
     m_dynamicData->m_topContext = static_cast<TopDUContext*>(this);
 
   d_func_dynamic()->setClassId(this);
   DUCHAIN_D_DYNAMIC(DUContext);
   d->m_contextType = Other;
   m_dynamicData->m_parentContext = nullptr;
 
   d->m_anonymousInParent = anonymous;
   d->m_inSymbolTable = false;
 
   if (parent) {
     m_dynamicData->m_indexInTopContext = parent->topContext()->m_dynamicData->allocateContextIndex(this, parent->isAnonymous() || anonymous);
     Q_ASSERT(m_dynamicData->m_indexInTopContext);
 
     if( !anonymous )
       parent->m_dynamicData->addChildContext(this);
     else
       m_dynamicData->m_parentContext = parent;
   }
 
   if(parent && !anonymous && parent->inSymbolTable())
     setInSymbolTable(true);
 }
 
 bool DUContext::isAnonymous() const {
   return d_func()->m_anonymousInParent || (m_dynamicData->m_parentContext && m_dynamicData->m_parentContext->isAnonymous());
 }
 
 DUContext::DUContext( DUContextData& dd, const RangeInRevision& range, DUContext * parent, bool anonymous )
   : DUChainBase(dd, range)
   , m_dynamicData(new DUContextDynamicData(this))
 {
   if(parent)
     m_dynamicData->m_topContext = parent->topContext();
   else
     m_dynamicData->m_topContext = static_cast<TopDUContext*>(this);
 
   DUCHAIN_D_DYNAMIC(DUContext);
   d->m_contextType = Other;
   m_dynamicData->m_parentContext = nullptr;
   d->m_inSymbolTable = false;
   d->m_anonymousInParent = anonymous;
   if (parent) {
     m_dynamicData->m_indexInTopContext = parent->topContext()->m_dynamicData->allocateContextIndex(this, parent->isAnonymous() || anonymous);
 
     if( !anonymous )
       parent->m_dynamicData->addChildContext(this);
     else
       m_dynamicData->m_parentContext = parent;
   }
 }
 
 DUContext::DUContext(DUContext& useDataFrom)
   : DUChainBase(useDataFrom)
   , m_dynamicData(useDataFrom.m_dynamicData)
 {
 }
 
 DUContext::~DUContext( )
 {
   TopDUContext* top = topContext();
 
   if(!top->deleting() || !top->isOnDisk()) {
     DUCHAIN_D_DYNAMIC(DUContext);
 
     if(d->m_owner.declaration())
       d->m_owner.declaration()->setInternalContext(nullptr);
 
     while( d->m_importersSize() != 0 ) {
       if(d->m_importers()[0].data())
         d->m_importers()[0].data()->removeImportedParentContext(this);
       else {
         qCDebug(LANGUAGE) << "importer disappeared";
         d->m_importersList().removeOne(d->m_importers()[0]);
       }
     }
 
     clearImportedParentContexts();
   }
 
   deleteChildContextsRecursively();
 
   if(!topContext()->deleting() || !topContext()->isOnDisk())
     deleteUses();
 
   deleteLocalDeclarations();
 
   //If the top-context is being delete, we don't need to spend time rebuilding the inner structure.
   //That's expensive, especially when the data is not dynamic.
   if(!top->deleting() || !top->isOnDisk()) {
     if (m_dynamicData->m_parentContext)
       m_dynamicData->m_parentContext->m_dynamicData->removeChildContext(this);
   }
 
   top->m_dynamicData->clearContextIndex(this);
 
   Q_ASSERT(d_func()->isDynamic() == (!top->deleting() || !top->isOnDisk() || top->m_dynamicData->isTemporaryContextIndex(m_dynamicData->m_indexInTopContext)));
   delete m_dynamicData;
 }
 
 QVector< DUContext * > DUContext::childContexts( ) const
 {
   ENSURE_CAN_READ
 
   return m_dynamicData->m_childContexts;
 }
 
 Declaration* DUContext::owner() const {
   ENSURE_CAN_READ
   return d_func()->m_owner.declaration();
 }
 
 void DUContext::setOwner(Declaration* owner) {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(DUContext);
   if( owner == d->m_owner.declaration() )
     return;
 
   Declaration* oldOwner = d->m_owner.declaration();
 
   d->m_owner = owner;
 
   //Q_ASSERT(!oldOwner || oldOwner->internalContext() == this);
   if( oldOwner && oldOwner->internalContext() == this )
     oldOwner->setInternalContext(nullptr);
 
 
   //The context set as internal context should always be the last opened context
   if( owner )
     owner->setInternalContext(this);
 }
 
 DUContext* DUContext::parentContext( ) const
 {
   //ENSURE_CAN_READ Commented out for performance reasons
 
   return m_dynamicData->m_parentContext.data();
 }
 
 void DUContext::setPropagateDeclarations(bool propagate)
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(DUContext);
 
   if(propagate == d->m_propagateDeclarations)
     return;
 
   d->m_propagateDeclarations = propagate;
 }
 
 bool DUContext::isPropagateDeclarations() const
 {
   return d_func()->m_propagateDeclarations;
 }
 
 QList<Declaration*> DUContext::findLocalDeclarations( const IndexedIdentifier& identifier,
                                                       const CursorInRevision& position,
                                                       const TopDUContext* topContext,
                                                       const AbstractType::Ptr& dataType,
                                                       SearchFlags flags ) const
 {
   ENSURE_CAN_READ
 
   DeclarationList ret;
   findLocalDeclarationsInternal(identifier, position.isValid() ? position : range().end, dataType, ret, topContext ? topContext : this->topContext(), flags);
   return ret;
 }
 
 QList<Declaration*> DUContext::findLocalDeclarations( const Identifier& identifier,
                                                       const CursorInRevision& position,
                                                       const TopDUContext* topContext,
                                                       const AbstractType::Ptr& dataType,
                                                       SearchFlags flags ) const
 {
   return findLocalDeclarations(IndexedIdentifier(identifier), position, topContext, dataType, flags);
 }
 
 namespace {
 
 bool contextIsChildOrEqual(const DUContext* childContext, const DUContext* context)
 {
   if(childContext == context)
     return true;
 
   if(childContext->parentContext())
     return contextIsChildOrEqual(childContext->parentContext(), context);
   else
     return false;
 }
 
 struct Checker
 {
   Checker(DUContext::SearchFlags flags, const AbstractType::Ptr& dataType,
           const CursorInRevision & position, DUContext::ContextType ownType)
   : m_flags(flags)
   , m_dataType(dataType)
   , m_position(position)
   , m_ownType(ownType)
   {
   }
 
   Declaration* check(Declaration* declaration) const
   {
     ///@todo This is C++-specific
     if (m_ownType != DUContext::Class && m_ownType != DUContext::Template
         && m_position.isValid() && m_position <= declaration->range().start)
     {
       return nullptr;
     }
 
     if (declaration->kind() == Declaration::Alias && !(m_flags & DUContext::DontResolveAliases)) {
       //Apply alias declarations
       AliasDeclaration* alias = static_cast<AliasDeclaration*>(declaration);
       if (alias->aliasedDeclaration().isValid()) {
         declaration = alias->aliasedDeclaration().declaration();
       } else {
         qCDebug(LANGUAGE) << "lost aliased declaration";
       }
     }
 
     if (declaration->kind() == Declaration::NamespaceAlias && !(m_flags & DUContext::NoFiltering)) {
       return nullptr;
     }
 
     if ((m_flags & DUContext::OnlyFunctions) && !declaration->isFunctionDeclaration()) {
       return nullptr;
     }
 
     if (m_dataType && m_dataType->indexed() != declaration->indexedType()) {
       return nullptr;
     }
 
     return declaration;
   }
 
   DUContext::SearchFlags m_flags;
   const AbstractType::Ptr m_dataType;
   const CursorInRevision m_position;
   DUContext::ContextType m_ownType;
 };
 
 }
 
 void DUContext::findLocalDeclarationsInternal(const Identifier& identifier, const CursorInRevision& position,
                                               const AbstractType::Ptr& dataType, DeclarationList& ret,
                                               const TopDUContext* source, SearchFlags flags) const
 {
     findLocalDeclarationsInternal(IndexedIdentifier(identifier), position, dataType, ret, source, flags);
 }
 
 void DUContext::findLocalDeclarationsInternal( const IndexedIdentifier& identifier,
                                                const CursorInRevision & position,
                                                const AbstractType::Ptr& dataType,
                                                DeclarationList& ret, const TopDUContext* /*source*/,
                                                SearchFlags flags ) const
 {
   Checker checker(flags, dataType, position, type());
 
   DUCHAIN_D(DUContext);
   if (d->m_inSymbolTable && !d->m_scopeIdentifier.isEmpty() && !identifier.isEmpty()) {
     //This context is in the symbol table, use the symbol-table to speed up the search
     QualifiedIdentifier id(scopeIdentifier(true) + identifier);
 
     TopDUContext* top = topContext();
 
     uint count;
     const IndexedDeclaration* declarations;
     PersistentSymbolTable::self().declarations(id, count, declarations);
     for (uint a = 0; a < count; ++a) {
       ///@todo Eventually do efficient iteration-free filtering
       if (declarations[a].topContextIndex() == top->ownIndex()) {
         Declaration* decl = declarations[a].declaration();
         if (decl && contextIsChildOrEqual(decl->context(), this)) {
           Declaration* checked = checker.check(decl);
           if (checked) {
             ret.append(checked);
           }
         }
       }
     }
   } else {
     //Iterate through all declarations
     DUContextDynamicData::VisibleDeclarationIterator it(m_dynamicData);
     while (it) {
       Declaration* declaration = *it;
       if (declaration && declaration->indexedIdentifier() == identifier) {
         Declaration* checked = checker.check(declaration);
         if (checked)
             ret.append(checked);
       }
       ++it;
     }
   }
 }
 
 bool DUContext::foundEnough( const DeclarationList& ret, SearchFlags flags ) const {
   if( !ret.isEmpty() && !(flags & DUContext::NoFiltering))
     return true;
   else
     return false;
 }
 
 bool DUContext::findDeclarationsInternal( const SearchItem::PtrList & baseIdentifiers,
                                           const CursorInRevision & position,
                                           const AbstractType::Ptr& dataType,
                                           DeclarationList& ret, const TopDUContext* source,
                                           SearchFlags flags, uint depth ) const
 {
   if (depth > maxParentDepth) {
     qCDebug(LANGUAGE) << "maximum depth reached in" << scopeIdentifier(true);
     return false;
   }
 
   DUCHAIN_D(DUContext);
   if (d->m_contextType != Namespace) {
     // If we're in a namespace, delay all the searching into the top-context, because only that has the overview to pick the correct declarations.
     for (int a = 0; a < baseIdentifiers.size(); ++a) {
       if (!baseIdentifiers[a]->isExplicitlyGlobal && baseIdentifiers[a]->next.isEmpty()) {
         // It makes no sense searching locally for qualified identifiers
         findLocalDeclarationsInternal(baseIdentifiers[a]->identifier, position, dataType, ret, source, flags);
       }
     }
 
     if (foundEnough(ret, flags)) {
       return true;
     }
   }
 
   ///Step 1: Apply namespace-aliases and -imports
   SearchItem::PtrList aliasedIdentifiers;
   //Because of namespace-imports and aliases, this identifier may need to be searched under multiple names
   applyAliases(baseIdentifiers, aliasedIdentifiers, position, false,  type() != DUContext::Namespace && type() != DUContext::Global);
 
   if (d->m_importedContextsSize() != 0) {
     ///Step 2: Give identifiers that are not marked as explicitly-global to imported contexts(explicitly global ones are treatead in TopDUContext)
     SearchItem::PtrList nonGlobalIdentifiers;
     foreach (const SearchItem::Ptr& identifier, aliasedIdentifiers) {
       if (!identifier->isExplicitlyGlobal) {
         nonGlobalIdentifiers << identifier;
       }
     }
 
     if (!nonGlobalIdentifiers.isEmpty()) {
       const auto& url = this->url();
       for(int import = d->m_importedContextsSize()-1; import >= 0; --import ) {
         if (position.isValid() && d->m_importedContexts()[import].position.isValid() && position < d->m_importedContexts()[import].position) {
           continue;
         }
 
         DUContext* context = d->m_importedContexts()[import].context(source);
 
         if (!context) {
           continue;
         } else if (context == this) {
           qCDebug(LANGUAGE) << "resolved self as import:" << scopeIdentifier(true);
           continue;
         }
 
         if (!context->findDeclarationsInternal(nonGlobalIdentifiers, url == context->url() ? position : context->range().end,
                                                dataType, ret, source, flags | InImportedParentContext, depth+1))
         {
           return false;
         }
       }
     }
   }
 
   if (foundEnough(ret, flags)) {
     return true;
   }
 
   ///Step 3: Continue search in parent-context
   if (!(flags & DontSearchInParent) && shouldSearchInParent(flags) && m_dynamicData->m_parentContext) {
     applyUpwardsAliases(aliasedIdentifiers, source);
     return m_dynamicData->m_parentContext->findDeclarationsInternal(aliasedIdentifiers,
                                                                     url() == m_dynamicData->m_parentContext->url() ? position : m_dynamicData->m_parentContext->range().end,
                                                                     dataType, ret, source, flags, depth);
   }
   return true;
 }
 
 QVector<QualifiedIdentifier> DUContext::fullyApplyAliases(const QualifiedIdentifier& id,
                                                           const TopDUContext* source) const
 {
   ENSURE_CAN_READ
 
   if(!source)
     source = topContext();
 
   SearchItem::PtrList identifiers;
   identifiers << SearchItem::Ptr(new SearchItem(id));
 
   const DUContext* current = this;
   while(current) {
     SearchItem::PtrList aliasedIdentifiers;
     current->applyAliases(identifiers, aliasedIdentifiers, CursorInRevision::invalid(), true, false);
     current->applyUpwardsAliases(identifiers, source);
 
     current = current->parentContext();
   }
 
   QVector<QualifiedIdentifier> ret;
   foreach (const SearchItem::Ptr& item, identifiers)
     ret += item->toList();
 
   return ret;
 }
 
 QList<Declaration*> DUContext::findDeclarations( const QualifiedIdentifier & identifier,
                                                  const CursorInRevision & position,
                                                  const AbstractType::Ptr& dataType,
                                                  const TopDUContext* topContext, SearchFlags flags) const
 {
   ENSURE_CAN_READ
 
   DeclarationList ret;
   // optimize: we don't want to allocate the top node always
   // so create it on stack but ref it so its not deleted by the smart pointer
   SearchItem item(identifier);
   item.ref.ref();
 
   SearchItem::PtrList identifiers{SearchItem::Ptr(&item)};
 
   findDeclarationsInternal(identifiers, position.isValid() ? position : range().end, dataType, ret, topContext ? topContext : this->topContext(), flags, 0);
 
   return ret;
 }
 
 bool DUContext::imports(const DUContext* origin, const CursorInRevision& /*position*/ ) const
 {
   ENSURE_CAN_READ
 
   QSet<const DUContextDynamicData*> recursionGuard;
   recursionGuard.reserve(8);
   return m_dynamicData->imports(origin, topContext(), &recursionGuard);
 }
 
 bool DUContext::addIndirectImport(const DUContext::Import& import) {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(DUContext);
 
   for(unsigned int a = 0; a < d->m_importedContextsSize(); ++a) {
     if(d->m_importedContexts()[a] == import) {
       d->m_importedContextsList()[a].position = import.position;
       return true;
     }
   }
 
   ///Do not sort the imported contexts by their own line-number, it makes no sense.
   ///Contexts added first, aka template-contexts, should stay in first place, so they are searched first.
 
   d->m_importedContextsList().append(import);
   return false;
 }
 
 void DUContext::addImportedParentContext( DUContext * context, const CursorInRevision& position, bool anonymous, bool /*temporary*/ )
 {
   ENSURE_CAN_WRITE
 
   if(context == this) {
     qCDebug(LANGUAGE) << "Tried to import self";
     return;
   }
   if(!context) {
     qCDebug(LANGUAGE) << "Tried to import invalid context";
     return;
   }
 
   Import import(context, this, position);
   if(addIndirectImport(import))
     return;
 
   if( !anonymous ) {
     ENSURE_CAN_WRITE_(context)
     context->m_dynamicData->addImportedChildContext(this);
   }
 }
 
 void DUContext::removeImportedParentContext( DUContext * context )
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(DUContext);
 
   Import import(context, this, CursorInRevision::invalid());
 
   for(unsigned int a = 0; a < d->m_importedContextsSize(); ++a) {
     if(d->m_importedContexts()[a] == import) {
       d->m_importedContextsList().remove(a);
       break;
     }
   }
 
   if( !context )
     return;
 
   context->m_dynamicData->removeImportedChildContext(this);
 }
 
 KDevVarLengthArray<IndexedDUContext> DUContext::indexedImporters() const
 {
   KDevVarLengthArray<IndexedDUContext> ret;
   if(owner())
     ret = Importers::self().importers(owner()->id()); //Add indirect importers to the list
 
   FOREACH_FUNCTION(const IndexedDUContext& ctx, d_func()->m_importers)
     ret.append(ctx);
 
   return ret;
 }
 
 QVector<DUContext*> DUContext::importers() const
 {
   ENSURE_CAN_READ
 
   QVector<DUContext*> ret;
   ret.reserve(d_func()->m_importersSize());
   FOREACH_FUNCTION(const IndexedDUContext& ctx, d_func()->m_importers)
     ret << ctx.context();
 
   if(owner()) {
     //Add indirect importers to the list
     const KDevVarLengthArray<IndexedDUContext> indirect = Importers::self().importers(owner()->id());
     ret.reserve(ret.size() + indirect.size());
     for (const IndexedDUContext ctx : indirect) {
       ret << ctx.context();
     }
   }
 
   return ret;
 }
 
 DUContext * DUContext::findContext( const CursorInRevision& position, DUContext* parent) const
 {
   ENSURE_CAN_READ
 
   if (!parent)
     parent = const_cast<DUContext*>(this);
 
   foreach (DUContext* context, parent->m_dynamicData->m_childContexts) {
     if (context->range().contains(position)) {
       DUContext* ret = findContext(position, context);
       if (!ret) {
         ret = context;
       }
 
       return ret;
     }
   }
 
   return nullptr;
 }
 
 bool DUContext::parentContextOf(DUContext* context) const
 {
   if (this == context)
     return true;
 
   foreach (DUContext* child, m_dynamicData->m_childContexts) {
     if (child->parentContextOf(context)) {
       return true;
     }
   }
 
   return false;
 }
 
 QVector<QPair<Declaration*, int>> DUContext::allDeclarations(const CursorInRevision& position,
                                                              const TopDUContext* topContext,
                                                              bool searchInParents) const
 {
   ENSURE_CAN_READ
 
   QVector<QPair<Declaration*, int>> ret;
 
   QHash<const DUContext*, bool> hadContexts;
   // Iterate back up the chain
   mergeDeclarationsInternal(ret, position, hadContexts, topContext ? topContext : this->topContext(), searchInParents);
 
   return ret;
 }
 
 QVector<Declaration*> DUContext::localDeclarations(const TopDUContext* source) const
 {
   ENSURE_CAN_READ
   // TODO: remove this parameter once we kill old-cpp
   Q_UNUSED(source);
   return m_dynamicData->m_localDeclarations;
 }
 
 void DUContext::mergeDeclarationsInternal(QVector<QPair<Declaration*, int>>& definitions,
                                           const CursorInRevision& position,
                                           QHash<const DUContext*, bool>& hadContexts,
                                           const TopDUContext* source,
                                           bool searchInParents, int currentDepth) const
 {
   ENSURE_CAN_READ
 
   if((currentDepth > 300 && currentDepth < 1000) || currentDepth > 1300) {
     qCDebug(LANGUAGE) << "too much depth";
     return;
   }
   DUCHAIN_D(DUContext);
 
     if(hadContexts.contains(this) && !searchInParents)
       return;
 
     if(!hadContexts.contains(this)) {
       hadContexts[this] = true;
 
       if( (type() == DUContext::Namespace || type() == DUContext::Global) && currentDepth < 1000 )
         currentDepth += 1000;
 
       {
         DUContextDynamicData::VisibleDeclarationIterator it(m_dynamicData);
         while(it) {
           Declaration* decl = *it;
 
           if ( decl && (!position.isValid() || decl->range().start <= position) )
             definitions << qMakePair(decl, currentDepth);
           ++it;
         }
       }
 
       for(int a = d->m_importedContextsSize()-1; a >= 0; --a) {
         const Import* import(&d->m_importedContexts()[a]);
         DUContext* context = import->context(source);
         while( !context && a > 0 ) {
           --a;
           import = &d->m_importedContexts()[a];
           context = import->context(source);
         }
         if( !context )
           break;
 
         if(context == this) {
           qCDebug(LANGUAGE) << "resolved self as import:" << scopeIdentifier(true);
           continue;
         }
 
 
         if( position.isValid() && import->position.isValid() && position < import->position )
           continue;
 
         context->mergeDeclarationsInternal(definitions, CursorInRevision::invalid(), hadContexts, source, searchInParents && context->shouldSearchInParent(InImportedParentContext) &&  context->parentContext()->type() == DUContext::Helper, currentDepth+1);
       }
     }
 
   ///Only respect the position if the parent-context is not a class(@todo this is language-dependent)
   if (parentContext() && searchInParents )
     parentContext()->mergeDeclarationsInternal(definitions, parentContext()->type() == DUContext::Class ? parentContext()->range().end : position, hadContexts, source, searchInParents, currentDepth+1);
 }
 
 void DUContext::deleteLocalDeclarations()
 {
   ENSURE_CAN_WRITE
   // It may happen that the deletion of one declaration triggers the deletion of another one
   // Therefore we copy the list of indexed declarations and work on those. Indexed declarations
   // will return zero for already deleted declarations.
   KDevVarLengthArray<LocalIndexedDeclaration> indexedLocal;
   if (d_func()->m_localDeclarations()) {
     indexedLocal.append(d_func()->m_localDeclarations(), d_func()->m_localDeclarationsSize());
   }
   foreach (const LocalIndexedDeclaration& indexed, m_dynamicData->m_localDeclarations) {
     delete indexed.data(topContext());
   }
   m_dynamicData->m_localDeclarations.clear();
 }
 
 void DUContext::deleteChildContextsRecursively()
 {
   ENSURE_CAN_WRITE
 
   // note: don't use qDeleteAll here because child ctx deletion changes m_dynamicData->m_childContexts
   // also note: foreach iterates on a copy, so this is safe
   foreach (DUContext* ctx, m_dynamicData->m_childContexts) {
     delete ctx;
   }
   m_dynamicData->m_childContexts.clear();
 }
 
 QVector<Declaration *> DUContext::clearLocalDeclarations( )
 {
   auto copy = m_dynamicData->m_localDeclarations;
   foreach (Declaration* dec, copy) {
     dec->setContext(nullptr);
   }
   return copy;
 }
 
 QualifiedIdentifier DUContext::scopeIdentifier(bool includeClasses) const
 {
   ENSURE_CAN_READ
 
   QualifiedIdentifier ret;
   m_dynamicData->scopeIdentifier(includeClasses, ret);
 
   return ret;
 }
 
 bool DUContext::equalScopeIdentifier(const DUContext* rhs) const
 {
   ENSURE_CAN_READ
 
   const DUContext* left = this;
   const DUContext* right = rhs;
 
   while(left || right) {
     if(!left || !right)
       return false;
 
     if(!(left->d_func()->m_scopeIdentifier == right->d_func()->m_scopeIdentifier))
       return false;
 
     left = left->parentContext();
     right = right->parentContext();
   }
 
   return true;
 }
 
 void DUContext::setLocalScopeIdentifier(const QualifiedIdentifier & identifier)
 {
   ENSURE_CAN_WRITE
   bool wasInSymbolTable = inSymbolTable();
   setInSymbolTable(false);
   d_func_dynamic()->m_scopeIdentifier = identifier;
   setInSymbolTable(wasInSymbolTable);
 }
 
 QualifiedIdentifier DUContext::localScopeIdentifier() const
 {
   //ENSURE_CAN_READ Commented out for performance reasons
 
   return d_func()->m_scopeIdentifier;
 }
 
 IndexedQualifiedIdentifier DUContext::indexedLocalScopeIdentifier() const {
   return d_func()->m_scopeIdentifier;
 }
 
 DUContext::ContextType DUContext::type() const
 {
   //ENSURE_CAN_READ This is disabled, because type() is called very often while searching, and it costs us performance
 
   return d_func()->m_contextType;
 }
 
 void DUContext::setType(ContextType type)
 {
   ENSURE_CAN_WRITE
 
   d_func_dynamic()->m_contextType = type;
 }
 
 QList<Declaration*> DUContext::findDeclarations(const Identifier& identifier, const CursorInRevision& position,
                                                 const TopDUContext* topContext, SearchFlags flags) const
 {
   return findDeclarations(IndexedIdentifier(identifier), position, topContext, flags);
 }
 
 QList<Declaration*> DUContext::findDeclarations(const IndexedIdentifier& identifier, const CursorInRevision& position,
                                                 const TopDUContext* topContext, SearchFlags flags) const
 {
   ENSURE_CAN_READ
 
   DeclarationList ret;
   SearchItem::PtrList identifiers;
   identifiers << SearchItem::Ptr(new SearchItem(false, identifier, SearchItem::PtrList()));
   findDeclarationsInternal(identifiers, position.isValid() ? position : range().end, AbstractType::Ptr(), ret, topContext ? topContext : this->topContext(), flags, 0);
   return ret;
 }
 
 void DUContext::deleteUse(int index)
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(DUContext);
   d->m_usesList().remove(index);
 }
 
 void DUContext::deleteUses()
 {
   ENSURE_CAN_WRITE
 
   DUCHAIN_D_DYNAMIC(DUContext);
   d->m_usesList().clear();
 }
 
 void DUContext::deleteUsesRecursively()
 {
   deleteUses();
 
   foreach (DUContext* childContext, m_dynamicData->m_childContexts) {
     childContext->deleteUsesRecursively();
   }
 }
 
 bool DUContext::inDUChain() const {
   if( d_func()->m_anonymousInParent || !m_dynamicData->m_parentContext)
     return false;
 
   TopDUContext* top = topContext();
   return top && top->inDUChain();
 }
 
 DUContext* DUContext::specialize(const IndexedInstantiationInformation& /*specialization*/,
                                  const TopDUContext* topContext, int /*upDistance*/)
 {
   if(!topContext)
     return nullptr;
   return this;
 }
 
 CursorInRevision DUContext::importPosition(const DUContext* target) const
 {
   ENSURE_CAN_READ
   DUCHAIN_D(DUContext);
   Import import(const_cast<DUContext*>(target), this, CursorInRevision::invalid());
   for(unsigned int a = 0; a < d->m_importedContextsSize(); ++a)
     if(d->m_importedContexts()[a] == import)
       return d->m_importedContexts()[a].position;
   return CursorInRevision::invalid();
 }
 
 QVector<DUContext::Import> DUContext::importedParentContexts() const
 {
   ENSURE_CAN_READ
   QVector<DUContext::Import> ret;
   ret.reserve(d_func()->m_importedContextsSize());
   FOREACH_FUNCTION(const DUContext::Import& import, d_func()->m_importedContexts)
     ret << import;
   return ret;
 }
 
 void DUContext::applyAliases(const SearchItem::PtrList& baseIdentifiers, SearchItem::PtrList& identifiers,
                              const CursorInRevision& position, bool canBeNamespace, bool onlyImports) const {
 
   DeclarationList imports;
   findLocalDeclarationsInternal(globalIndexedImportIdentifier(), position, AbstractType::Ptr(), imports, topContext(), DUContext::NoFiltering);
 
   if(imports.isEmpty() && onlyImports) {
     identifiers = baseIdentifiers;
     return;
   }
 
   for ( const SearchItem::Ptr& identifier : baseIdentifiers ) {
     bool addUnmodified = true;
 
     if( !identifier->isExplicitlyGlobal ) {
 
       if( !imports.isEmpty() )
       {
         //We have namespace-imports.
         foreach ( Declaration* importDecl, imports )
         {
           //Search for the identifier with the import-identifier prepended
           if(dynamic_cast<NamespaceAliasDeclaration*>(importDecl))
           {
             NamespaceAliasDeclaration* alias = static_cast<NamespaceAliasDeclaration*>(importDecl);
             identifiers.append( SearchItem::Ptr( new SearchItem( alias->importIdentifier(), identifier ) ) ) ;
           }else{
             qCDebug(LANGUAGE) << "Declaration with namespace alias identifier has the wrong type" << importDecl->url().str() << importDecl->range().castToSimpleRange();
           }
         }
       }
 
       if( !identifier->isEmpty() && (identifier->hasNext() || canBeNamespace) ) {
 
         DeclarationList aliases;
         findLocalDeclarationsInternal(identifier->identifier, position, AbstractType::Ptr(), imports, nullptr, DUContext::NoFiltering);
 
         if(!aliases.isEmpty()) {
           //The first part of the identifier has been found as a namespace-alias.
           //In c++, we only need the first alias. However, just to be correct, follow them all for now.
           foreach ( Declaration* aliasDecl, aliases )
           {
             if(!dynamic_cast<NamespaceAliasDeclaration*>(aliasDecl))
               continue;
 
             addUnmodified = false; //The un-modified identifier can be ignored, because it will be replaced with the resolved alias
             NamespaceAliasDeclaration* alias = static_cast<NamespaceAliasDeclaration*>(aliasDecl);
 
             //Create an identifier where namespace-alias part is replaced with the alias target
             identifiers.append( SearchItem::Ptr( new SearchItem( alias->importIdentifier(), identifier->next ) ) ) ;
           }
         }
       }
     }
 
     if( addUnmodified )
         identifiers.append(identifier);
   }
 }
 
 void DUContext::applyUpwardsAliases(SearchItem::PtrList& identifiers, const TopDUContext* /*source*/) const {
 
   if(type() == Namespace) {
     if(d_func()->m_scopeIdentifier.isEmpty())
       return;
 
     //Make sure we search for the items in all namespaces of the same name, by duplicating each one with the namespace-identifier prepended.
     //We do this by prepending items to the current identifiers that equal the local scope identifier.
     SearchItem::Ptr newItem( new SearchItem(d_func()->m_scopeIdentifier.identifier()) );
 
     //This will exclude explictly global identifiers
     newItem->addToEachNode( identifiers );
 
     if(!newItem->next.isEmpty()) {
       //Prepend the full scope before newItem
       DUContext* parent = m_dynamicData->m_parentContext.data();
       while(parent) {
         newItem = SearchItem::Ptr( new SearchItem(parent->d_func()->m_scopeIdentifier, newItem) );
         parent = parent->m_dynamicData->m_parentContext.data();
       }
 
       newItem->isExplicitlyGlobal = true;
       identifiers.insert(0, newItem);
     }
   }
 }
 
 bool DUContext::shouldSearchInParent(SearchFlags flags) const
 {
   return (parentContext() && parentContext()->type() == DUContext::Helper && (flags & InImportedParentContext))
           || !(flags & InImportedParentContext);
 }
 
 const Use* DUContext::uses() const
 {
   ENSURE_CAN_READ
 
   return d_func()->m_uses();
 }
 
 bool DUContext::declarationHasUses(Declaration* decl)
 {
   return DUChain::uses()->hasUses(decl->id());
 }
 
 int DUContext::usesCount() const
 {
   return d_func()->m_usesSize();
 }
 
 bool usesRangeLessThan(const Use& left, const Use& right)
 {
   return left.m_range.start < right.m_range.start;
 }
 
 int DUContext::createUse(int declarationIndex, const RangeInRevision& range, int insertBefore)
 {
   DUCHAIN_D_DYNAMIC(DUContext);
   ENSURE_CAN_WRITE
 
   Use use(range, declarationIndex);
   if(insertBefore == -1) {
     //Find position where to insert
     const unsigned int size = d->m_usesSize();
     const Use* uses = d->m_uses();
     const Use* lowerBound = std::lower_bound(uses, uses + size, use, usesRangeLessThan);
     insertBefore = lowerBound - uses;
     // comment out to test this:
     /*
     unsigned int a = 0;
     for(; a < size && range.start > uses[a].m_range.start; ++a) {
     }
     Q_ASSERT(a == insertBefore);
     */
   }
 
   d->m_usesList().insert(insertBefore, use);
 
   return insertBefore;
 }
 
 void DUContext::changeUseRange(int useIndex, const RangeInRevision& range)
 {
   ENSURE_CAN_WRITE
   d_func_dynamic()->m_usesList()[useIndex].m_range = range;
 }
 
 void DUContext::setUseDeclaration(int useNumber, int declarationIndex)
 {
   ENSURE_CAN_WRITE
   d_func_dynamic()->m_usesList()[useNumber].m_declarationIndex = declarationIndex;
 }
 
 
 DUContext * DUContext::findContextAt(const CursorInRevision & position, bool includeRightBorder) const
 {
   ENSURE_CAN_READ
 
 //   qCDebug(LANGUAGE) << "searchign" << position << "in:" << scopeIdentifier(true).toString() << range() << includeRightBorder;
 
   if (!range().contains(position) && (!includeRightBorder || range().end != position)) {
 //     qCDebug(LANGUAGE) << "mismatch";
     return nullptr;
   }
 
   const auto childContexts = m_dynamicData->m_childContexts;
   for(int a = childContexts.size() - 1; a >= 0; --a) {
     if (DUContext* specific = childContexts[a]->findContextAt(position, includeRightBorder)) {
       return specific;
     }
   }
 
   return const_cast<DUContext*>(this);
 }
 
 Declaration * DUContext::findDeclarationAt(const CursorInRevision & position) const
 {
   ENSURE_CAN_READ
 
   if (!range().contains(position))
     return nullptr;
 
   foreach (Declaration* child, m_dynamicData->m_localDeclarations) {
     if (child->range().contains(position)) {
       return child;
     }
   }
 
   return nullptr;
 }
 
 DUContext* DUContext::findContextIncluding(const RangeInRevision& range) const
 {
   ENSURE_CAN_READ
 
   if (!this->range().contains(range))
     return nullptr;
 
   foreach (DUContext* child, m_dynamicData->m_childContexts) {
     if (DUContext* specific = child->findContextIncluding(range)) {
       return specific;
     }
   }
 
   return const_cast<DUContext*>(this);
 }
 
 int DUContext::findUseAt(const CursorInRevision & position) const
 {
   ENSURE_CAN_READ
 
   if (!range().contains(position))
     return -1;
 
   for(unsigned int a = 0; a < d_func()->m_usesSize(); ++a)
     if (d_func()->m_uses()[a].m_range.contains(position))
       return a;
 
   return -1;
 }
 
 bool DUContext::inSymbolTable() const
 {
   return d_func()->m_inSymbolTable;
 }
 
 void DUContext::setInSymbolTable(bool inSymbolTable)
 {
   d_func_dynamic()->m_inSymbolTable = inSymbolTable;
 }
 
 
 void DUContext::clearImportedParentContexts()
 {
   ENSURE_CAN_WRITE
   DUCHAIN_D_DYNAMIC(DUContext);
 
   while( d->m_importedContextsSize() != 0 ) {
     DUContext* ctx = d->m_importedContexts()[0].context(nullptr, false);
     if(ctx)
       ctx->m_dynamicData->removeImportedChildContext(this);
 
     d->m_importedContextsList().removeOne(d->m_importedContexts()[0]);
   }
 }
 
 void DUContext::cleanIfNotEncountered(const QSet<DUChainBase*>& encountered)
 {
   ENSURE_CAN_WRITE
 
   // It may happen that the deletion of one declaration triggers the deletion of another one
   // Therefore we copy the list of indexed declarations and work on those. Indexed declarations
   // will return zero for already deleted declarations.
   KDevVarLengthArray<LocalIndexedDeclaration> indexedLocal;
   if (d_func()->m_localDeclarations()) {
     indexedLocal.append(d_func()->m_localDeclarations(), d_func()->m_localDeclarationsSize());
   }
   foreach (const LocalIndexedDeclaration& indexed, m_dynamicData->m_localDeclarations) {
     auto dec = indexed.data(topContext());
     if (dec && !encountered.contains(dec) && (!dec->isAutoDeclaration() || !dec->hasUses())) {
       delete dec;
     }
   }
 
   foreach (DUContext* childContext, m_dynamicData->m_childContexts) {
     if (!encountered.contains(childContext)) {
       delete childContext;
     }
   }
 }
 
 TopDUContext* DUContext::topContext() const
 {
   return m_dynamicData->m_topContext;
 }
 
 QWidget* DUContext::createNavigationWidget(Declaration* decl, TopDUContext* topContext,
                                            const QString& htmlPrefix, const QString& htmlSuffix,
                                            AbstractNavigationWidget::DisplayHints hints) const
 {
   if (decl) {
     AbstractNavigationWidget* widget = new AbstractNavigationWidget;
     widget->setDisplayHints(hints);
     AbstractDeclarationNavigationContext* context = new AbstractDeclarationNavigationContext(DeclarationPointer(decl),
                                                                                              TopDUContextPointer(topContext));
     context->setPrefixSuffix(htmlPrefix, htmlSuffix);
     widget->setContext(NavigationContextPointer(context));
     return widget;
   } else {
     return nullptr;
   }
 }
 
 QVector<RangeInRevision> allUses(DUContext* context, int declarationIndex, bool noEmptyUses)
 {
   QVector<RangeInRevision> ret;
   for(int a = 0; a < context->usesCount(); ++a)
     if(context->uses()[a].m_declarationIndex == declarationIndex)
       if(!noEmptyUses || !context->uses()[a].m_range.isEmpty())
         ret << context->uses()[a].m_range;
 
   foreach(DUContext* child, context->childContexts())
     ret += allUses(child, declarationIndex, noEmptyUses);
 
   return ret;
 }
 
 DUContext::SearchItem::SearchItem(const QualifiedIdentifier& id, const Ptr& nextItem, int start)
 : isExplicitlyGlobal(start == 0 ? id.explicitlyGlobal() : false)
 {
   if(!id.isEmpty()) {
     if(id.count() > start)
       identifier = id.indexedAt(start);
 
     if(id.count() > start+1)
       addNext(Ptr( new SearchItem(id, nextItem, start+1) ));
     else if(nextItem)
       next.append(nextItem);
   }else if(nextItem) {
     ///If there is no prefix, just copy nextItem
     isExplicitlyGlobal = nextItem->isExplicitlyGlobal;
     identifier = nextItem->identifier;
     next = nextItem->next;
   }
 }
 
 DUContext::SearchItem::SearchItem(const QualifiedIdentifier& id, const PtrList& nextItems, int start)
 : isExplicitlyGlobal(start == 0 ? id.explicitlyGlobal() : false)
 {
   if(id.count() > start)
     identifier = id.indexedAt(start);
 
   if(id.count() > start+1)
     addNext(Ptr( new SearchItem(id, nextItems, start+1) ));
   else
     next = nextItems;
 }
 
 DUContext::SearchItem::SearchItem(bool explicitlyGlobal, const IndexedIdentifier& id, const PtrList& nextItems)
   : isExplicitlyGlobal(explicitlyGlobal)
   , identifier(id)
   , next(nextItems)
 {
 }
 
 DUContext::SearchItem::SearchItem(bool explicitlyGlobal, const IndexedIdentifier& id, const Ptr& nextItem)
   : isExplicitlyGlobal(explicitlyGlobal)
   , identifier(id)
 {
   next.append(nextItem);
 }
 
 bool DUContext::SearchItem::match(const QualifiedIdentifier& id, int offset) const {
   if(id.isEmpty()) {
     if(identifier.isEmpty() && next.isEmpty())
       return true;
     else
       return false;
   }
 
   if(id.at(offset) != identifier) //The identifier is different
     return false;
 
   if(offset == id.count()-1) {
     if(next.isEmpty())
       return true; //match
     else
       return false; //id is too short
   }
 
   for(int a = 0; a < next.size(); ++a)
     if(next[a]->match(id, offset+1))
       return true;
 
   return false;
 }
 
 bool DUContext::SearchItem::isEmpty() const {
   return identifier.isEmpty();
 }
 
 bool DUContext::SearchItem::hasNext() const {
   return !next.isEmpty();
 }
 
 QVector<QualifiedIdentifier> DUContext::SearchItem::toList(const QualifiedIdentifier& prefix) const
 {
   QVector<QualifiedIdentifier> ret;
 
   QualifiedIdentifier id = prefix;
   if(id.isEmpty())
   id.setExplicitlyGlobal(isExplicitlyGlobal);
   if(!identifier.isEmpty())
     id.push(identifier);
 
   if(next.isEmpty()) {
     ret << id;
   } else {
     for(int a = 0; a < next.size(); ++a)
       ret += next[a]->toList(id);
   }
   return ret;
 }
 
 
 void DUContext::SearchItem::addNext(const SearchItem::Ptr& other) {
   next.append(other);
 }
 
 void DUContext::SearchItem::addToEachNode(const SearchItem::Ptr& other) {
   if(other->isExplicitlyGlobal)
     return;
 
   next.append(other);
   for(int a = 0; a < next.size()-1; ++a)
     next[a]->addToEachNode(other);
 }
 
 void DUContext::SearchItem::addToEachNode(const SearchItem::PtrList& other) {
   int added = 0;
   for (const SearchItem::Ptr& o : other) {
     if(!o->isExplicitlyGlobal) {
       next.append(o);
       ++added;
     }
   }
 
   for(int a = 0; a < next.size()-added; ++a)
     next[a]->addToEachNode(other);
 }
 
 DUContext::Import::Import(DUContext* _context, const DUContext* importer, const CursorInRevision& _position)
   : position(_position)
 {
   if(_context && _context->owner() && (_context->owner()->specialization().index() || (importer && importer->topContext() != _context->topContext()))) {
     m_declaration = _context->owner()->id();
   }else{
     m_context = _context;
   }
 }
 
 DUContext::Import::Import(const DeclarationId& id, const CursorInRevision& _position)
   : position(_position)
   , m_declaration(id)
 {
 }
 
 DUContext* DUContext::Import::context(const TopDUContext* topContext, bool instantiateIfRequired) const {
   if(m_declaration.isValid()) {
-    Declaration* decl = m_declaration.getDeclaration(topContext, instantiateIfRequired);
+    Declaration* decl = m_declaration.declaration(topContext, instantiateIfRequired);
     //This first case rests on the assumption that no context will ever import a function's expression context
     //More accurately, that no specialized or cross-topContext imports will, but if the former assumption fails the latter will too
     if (AbstractFunctionDeclaration *functionDecl = dynamic_cast<AbstractFunctionDeclaration*>(decl))
     {
       if (functionDecl->internalFunctionContext()) {
         return functionDecl->internalFunctionContext();
       } else {
         qCWarning(LANGUAGE) << "Import of function declaration without internal function context encountered!";
       }
     }
     if(decl)
       return decl->logicalInternalContext(topContext);
     else
       return nullptr;
   }else{
     return m_context.data();
   }
 }
 
 bool DUContext::Import::isDirect() const {
   return m_context.isValid();
 }
 
 void DUContext::visit(DUChainVisitor& visitor)
 {
   ENSURE_CAN_READ
 
   visitor.visit(this);
 
   foreach (Declaration* decl, m_dynamicData->m_localDeclarations) {
     visitor.visit(decl);
   }
 
   foreach (DUContext* childContext, m_dynamicData->m_childContexts) {
     childContext->visit(visitor);
   }
 }
 
 static bool sortByRange(const DUChainBase* lhs, const DUChainBase* rhs)
 {
   return lhs->range() < rhs->range();
 }
 
 void DUContext::resortLocalDeclarations()
 {
   ENSURE_CAN_WRITE
 
   std::sort(m_dynamicData->m_localDeclarations.begin(), m_dynamicData->m_localDeclarations.end(), sortByRange);
 
   auto top = topContext();
   auto& declarations = d_func_dynamic()->m_localDeclarationsList();
   std::sort(declarations.begin(), declarations.end(),
             [top] (const LocalIndexedDeclaration& lhs, const LocalIndexedDeclaration& rhs) {
               return lhs.data(top)->range() < rhs.data(top)->range();
             });
 }
 
 void DUContext::resortChildContexts()
 {
   ENSURE_CAN_WRITE
 
   std::sort(m_dynamicData->m_childContexts.begin(), m_dynamicData->m_childContexts.end(), sortByRange);
 
   auto top = topContext();
   auto& contexts = d_func_dynamic()->m_childContextsList();
   std::sort(contexts.begin(), contexts.end(),
             [top] (const LocalIndexedDUContext& lhs, const LocalIndexedDUContext& rhs) {
               return lhs.data(top)->range() < rhs.data(top)->range();
             });
 }
 
 }
diff --git a/kdevplatform/language/duchain/functiondefinition.cpp b/kdevplatform/language/duchain/functiondefinition.cpp
index 60ee0e6443..103152520e 100644
--- a/kdevplatform/language/duchain/functiondefinition.cpp
+++ b/kdevplatform/language/duchain/functiondefinition.cpp
@@ -1,101 +1,101 @@
 /* This file is part of KDevelop
     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 "functiondefinition.h"
 #include "duchainregister.h"
 #include "definitions.h"
 
 namespace KDevelop {
 REGISTER_DUCHAIN_ITEM(FunctionDefinition);
 
 FunctionDefinition::FunctionDefinition(FunctionDefinitionData& data) : FunctionDeclaration(data)
 {
 }
 
 FunctionDefinition::FunctionDefinition(const RangeInRevision& range, DUContext* context)
   : FunctionDeclaration(*new FunctionDefinitionData, range)
 {
   d_func_dynamic()->setClassId(this);
   setDeclarationIsDefinition(true);
   if( context )
     setContext( context );
 }
 
 FunctionDefinition::FunctionDefinition(const FunctionDefinition& rhs) : FunctionDeclaration(*new FunctionDefinitionData(*rhs.d_func())) {
 }
 
 FunctionDefinition::~FunctionDefinition() {
   if(!topContext()->isOnDisk())
     DUChain::definitions()->removeDefinition(d_func()->m_declaration, this);
 }
 
 Declaration* FunctionDefinition::declaration(const TopDUContext* topContext) const
 {
   ENSURE_CAN_READ
   
-  const KDevVarLengthArray<Declaration*> declarations = d_func()->m_declaration.getDeclarations(topContext ? topContext : this->topContext());
+  const KDevVarLengthArray<Declaration*> declarations = d_func()->m_declaration.declarations(topContext ? topContext : this->topContext());
   
   for (Declaration* decl : declarations) {
     if(!dynamic_cast<FunctionDefinition*>(decl))
       return decl;
   }
   
   return nullptr;
 }
 
 bool FunctionDefinition::hasDeclaration() const
 {
   return d_func()->m_declaration.isValid();
 }
 
 void FunctionDefinition::setDeclaration(Declaration* declaration)
 {
   ENSURE_CAN_WRITE
 
   if(declaration) {
     DUChain::definitions()->addDefinition(declaration->id(), this);
     d_func_dynamic()->m_declaration = declaration->id();
   }else{
     if(d_func()->m_declaration.isValid()) {
       DUChain::definitions()->removeDefinition(d_func()->m_declaration, this);
       d_func_dynamic()->m_declaration = DeclarationId();
     }
   }
 }
 
 FunctionDefinition* FunctionDefinition::definition(const Declaration* decl)
 {
   ENSURE_CHAIN_READ_LOCKED
   if (!decl) {
     return nullptr;
   }
 
   const KDevVarLengthArray<IndexedDeclaration> allDefinitions = DUChain::definitions()->definitions(decl->id());
   for (const IndexedDeclaration decl : allDefinitions) {
     if(decl.data()) ///@todo Find better ways of deciding which definition to use
       return dynamic_cast<FunctionDefinition*>(decl.data());
   }
   return nullptr;
 }
 
 Declaration* FunctionDefinition::clonePrivate() const
 {
   return new FunctionDefinition(*new FunctionDefinitionData(*d_func()));
 }
 
 }
diff --git a/kdevplatform/language/duchain/identifier.cpp b/kdevplatform/language/duchain/identifier.cpp
index 16815c05cf..3a80e32725 100644
--- a/kdevplatform/language/duchain/identifier.cpp
+++ b/kdevplatform/language/duchain/identifier.cpp
@@ -1,1594 +1,1594 @@
 /* This file is part of KDevelop
     Copyright 2006 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 "identifier.h"
 
 #include <QHash>
 #include "stringhelpers.h"
 #include "appendedlist_static.h"
 #include "serialization/itemrepository.h"
 #include "util/kdevhash.h"
 #include <debug.h>
 
 #include <serialization/indexedstring.h>
 #include <utility>
 
 #define ifDebug(x)
 
 namespace KDevelop
 {
 template<bool dynamic = false>
 class IdentifierPrivate
 {
 public:
   IdentifierPrivate()
   {
   }
 
   template<bool rhsDynamic>
   explicit IdentifierPrivate(const IdentifierPrivate<rhsDynamic>& rhs)
     : m_unique(rhs.m_unique)
     , m_identifier(rhs.m_identifier)
     , m_refCount(0)
     , m_hash(rhs.m_hash)
   {
     copyListsFrom(rhs);
   }
 
   ~IdentifierPrivate()
   {
     templateIdentifiersList.free(const_cast<IndexedTypeIdentifier*>(templateIdentifiers()));
   }
 
   //Flags the stored hash-value invalid
   void clearHash()
   {
     //This is always called on an object private to an Identifier, so there is no threading-problem.
     Q_ASSERT(dynamic);
     m_hash = 0;
   }
 
   uint hash() const
   {
     // Since this only needs reading and the data needs not to be private, this may be called by
     // multiple threads simultaneously, so computeHash() must be thread-safe.
     if( !m_hash && dynamic )
       computeHash();
     return m_hash;
   }
 
   int m_unique = 0;
   IndexedString m_identifier;
   uint m_refCount = 0;
 
   START_APPENDED_LISTS_STATIC(IdentifierPrivate)
 
   APPENDED_LIST_FIRST_STATIC(IndexedTypeIdentifier, templateIdentifiers)
 
   END_APPENDED_LISTS_STATIC(templateIdentifiers)
 
   uint itemSize() const
   {
     return sizeof(IdentifierPrivate<false>) + lastOffsetBehind();
   }
 
   void computeHash() const
   {
     Q_ASSERT(dynamic);
     //this must stay thread-safe(may be called by multiple threads at a time)
     //The thread-safety is given because all threads will have the same result, and it will only be written once at the end.
     KDevHash kdevhash;
     kdevhash << m_identifier.hash() << m_unique;
     FOREACH_FUNCTION_STATIC(const IndexedTypeIdentifier& templateIdentifier, templateIdentifiers)
       kdevhash << templateIdentifier.hash();
     m_hash = kdevhash;
   }
 
   mutable uint m_hash = 0;
 };
 
 typedef IdentifierPrivate<true> DynamicIdentifierPrivate;
 typedef IdentifierPrivate<false> ConstantIdentifierPrivate;
 
 struct IdentifierItemRequest
 {
   IdentifierItemRequest(const DynamicIdentifierPrivate& identifier)
     : m_identifier(identifier)
   {
     identifier.hash(); //Make sure the hash is valid by calling this
   }
 
   enum {
     AverageSize = sizeof(IdentifierPrivate<false>)+4
   };
 
   //Should return the hash-value associated with this request(For example the hash of a string)
   uint hash() const
   {
     return m_identifier.hash();
   }
 
   //Should return the size of an item created with createItem
   uint itemSize() const
   {
       return m_identifier.itemSize();
   }
   //Should create an item where the information of the requested item is permanently stored. The pointer
   //@param item equals an allocated range with the size of itemSize().
   void createItem(ConstantIdentifierPrivate* item) const
   {
     new (item) ConstantIdentifierPrivate(m_identifier);
   }
 
   static bool persistent(const ConstantIdentifierPrivate* item)
   {
     return (bool)item->m_refCount;
   }
 
   static void destroy(ConstantIdentifierPrivate* item, AbstractItemRepository&)
   {
     item->~ConstantIdentifierPrivate();
   }
 
   //Should return whether the here requested item equals the given item
   bool equals(const ConstantIdentifierPrivate* item) const
   {
     return item->m_hash == m_identifier.m_hash
         && item->m_unique == m_identifier.m_unique
         && item->m_identifier == m_identifier.m_identifier
         && m_identifier.listsEqual(*item);
   }
 
   const DynamicIdentifierPrivate& m_identifier;
 };
 
 using IdentifierRepository = RepositoryManager< ItemRepository<ConstantIdentifierPrivate, IdentifierItemRequest>, false>;
 static IdentifierRepository& identifierRepository()
 {
   static IdentifierRepository identifierRepositoryObject(QStringLiteral("Identifier Repository"));
   return identifierRepositoryObject;
 }
 
 static uint emptyConstantIdentifierPrivateIndex()
 {
   static const uint index = identifierRepository()->index(DynamicIdentifierPrivate());
   return index;
 }
 
 static const ConstantIdentifierPrivate* emptyConstantIdentifierPrivate()
 {
   static const ConstantIdentifierPrivate item;
   return &item;
 }
 
 bool IndexedIdentifier::isEmpty() const
 {
-  return index == emptyConstantIdentifierPrivateIndex();
+  return m_index == emptyConstantIdentifierPrivateIndex();
 }
 
 
 /**
  * Before something is modified in QualifiedIdentifierPrivate, it must be made sure that
  * it is private to the QualifiedIdentifier it is used in(@see QualifiedIdentifier::prepareWrite)
  */
 template<bool dynamic>
 class QualifiedIdentifierPrivate
 {
 public:
   QualifiedIdentifierPrivate()
     : m_explicitlyGlobal(false)
     , m_isExpression(false)
 
   {
   }
 
   template<bool rhsDynamic>
   explicit QualifiedIdentifierPrivate(const QualifiedIdentifierPrivate<rhsDynamic>& rhs)
     : m_explicitlyGlobal(rhs.m_explicitlyGlobal)
     , m_isExpression(rhs.m_isExpression)
     , m_hash(rhs.m_hash)
     , m_refCount(0)
   {
     copyListsFrom(rhs);
   }
 
   ~QualifiedIdentifierPrivate()
   {
     identifiersList.free(const_cast<IndexedIdentifier*>(identifiers()));
   }
 
   bool m_explicitlyGlobal:1;
   bool m_isExpression:1;
   mutable uint m_hash = 0;
   uint m_refCount = 0;
 
   START_APPENDED_LISTS_STATIC(QualifiedIdentifierPrivate)
 
   APPENDED_LIST_FIRST_STATIC(IndexedIdentifier, identifiers)
 
   END_APPENDED_LISTS_STATIC(identifiers)
 
   uint itemSize() const
   {
     return sizeof(QualifiedIdentifierPrivate<false>) + lastOffsetBehind();
   }
 
   //Constructs m_identifiers
   void splitIdentifiers( const QString& str, int start )
   {
     Q_ASSERT(dynamic);
     uint currentStart = start;
 
     while( currentStart < (uint)str.length() ) {
       identifiersList.append(IndexedIdentifier(Identifier( str, currentStart, &currentStart )));
       while (currentStart < (uint)str.length() && (str[currentStart] == QLatin1Char(' ')))
         ++currentStart;
       currentStart += 2; //Skip "::"
     }
   }
 
   inline void clearHash() const
   {
     m_hash = 0;
   }
 
   uint hash() const
   {
     if( m_hash == 0 ) {
       KDevHash hash;
 
       quint32 bitfields = static_cast<quint32>(m_explicitlyGlobal)
         | (m_isExpression << 1);
       hash << bitfields << identifiersSize();
       FOREACH_FUNCTION_STATIC( const IndexedIdentifier& identifier, identifiers ) {
-        hash << identifier.getIndex();
+        hash << identifier.index();
       }
 
       m_hash = hash;
     }
     return m_hash;
   }
 };
 
 typedef QualifiedIdentifierPrivate<true> DynamicQualifiedIdentifierPrivate;
 typedef QualifiedIdentifierPrivate<false> ConstantQualifiedIdentifierPrivate;
 
 struct QualifiedIdentifierItemRequest
 {
   QualifiedIdentifierItemRequest(const DynamicQualifiedIdentifierPrivate& identifier)
     : m_identifier(identifier)
   {
     identifier.hash(); //Make sure the hash is valid by calling this
   }
 
   enum {
     AverageSize = sizeof(QualifiedIdentifierPrivate<false>)+8
   };
 
   //Should return the hash-value associated with this request(For example the hash of a string)
   uint hash() const
   {
     return m_identifier.hash();
   }
 
   //Should return the size of an item created with createItem
   uint itemSize() const
   {
     return m_identifier.itemSize();
   }
 
   /**
    * Should create an item where the information of the requested item is permanently stored. The pointer
    * @param item equals an allocated range with the size of itemSize().
    */
   void createItem(ConstantQualifiedIdentifierPrivate* item) const
   {
     Q_ASSERT(shouldDoDUChainReferenceCounting(item));
     Q_ASSERT(shouldDoDUChainReferenceCounting(((char*)item) + (itemSize()-1)));
     new (item) ConstantQualifiedIdentifierPrivate(m_identifier);
   }
 
   static bool persistent(const ConstantQualifiedIdentifierPrivate* item)
   {
     return (bool)item->m_refCount;
   }
 
   static void destroy(ConstantQualifiedIdentifierPrivate* item, AbstractItemRepository&)
   {
     Q_ASSERT(shouldDoDUChainReferenceCounting(item));
     item->~ConstantQualifiedIdentifierPrivate();
   }
 
   //Should return whether the here requested item equals the given item
   bool equals(const ConstantQualifiedIdentifierPrivate* item) const
   {
     return item->m_explicitlyGlobal == m_identifier.m_explicitlyGlobal
         && item->m_isExpression == m_identifier.m_isExpression
         && item->m_hash == m_identifier.m_hash
         && m_identifier.listsEqual(*item);
   }
 
   const DynamicQualifiedIdentifierPrivate& m_identifier;
 };
 
 using QualifiedIdentifierRepository = RepositoryManager< ItemRepository<ConstantQualifiedIdentifierPrivate, QualifiedIdentifierItemRequest>, false>;
 
 static QualifiedIdentifierRepository& qualifiedidentifierRepository()
 {
   static QualifiedIdentifierRepository repo(QStringLiteral("Qualified Identifier Repository"), 1, [] () -> AbstractRepositoryManager* { return &identifierRepository(); });
   return repo;
 }
 
 static uint emptyConstantQualifiedIdentifierPrivateIndex()
 {
   static const uint index = qualifiedidentifierRepository()->index(DynamicQualifiedIdentifierPrivate());
   return index;
 }
 
 static const ConstantQualifiedIdentifierPrivate* emptyConstantQualifiedIdentifierPrivate()
 {
   static const ConstantQualifiedIdentifierPrivate item;
   return &item;
 }
 
 Identifier::Identifier(const Identifier& rhs)
 {
   rhs.makeConstant();
   cd = rhs.cd;
   m_index = rhs.m_index;
 }
 
 Identifier::Identifier(uint index)
   : m_index(index)
 {
   Q_ASSERT(m_index);
   cd = identifierRepository()->itemFromIndex(index);
 }
 
 Identifier::Identifier(const IndexedString& str)
 {
   if (str.isEmpty()) {
     m_index = emptyConstantIdentifierPrivateIndex();
     cd = emptyConstantIdentifierPrivate();
   } else {
     m_index = 0;
     dd = new IdentifierPrivate<true>;
     dd->m_identifier = str;
   }
 }
 
 Identifier::Identifier(const QString& id, uint start, uint* takenRange)
 {
   if (id.isEmpty()) {
     m_index = emptyConstantIdentifierPrivateIndex();
     cd = emptyConstantIdentifierPrivate();
     return;
   }
 
   m_index = 0;
   dd = new IdentifierPrivate<true>;
 
   ///Extract template-parameters
   ParamIterator paramIt(QStringLiteral("<>:"), id, start);
   dd->m_identifier = IndexedString(paramIt.prefix().trimmed());
   while( paramIt ) {
     appendTemplateIdentifier( IndexedTypeIdentifier(IndexedQualifiedIdentifier(QualifiedIdentifier(*paramIt))) );
     ++paramIt;
   }
 
   if( takenRange )
     *takenRange = paramIt.position();
 }
 
 Identifier::Identifier()
   : m_index(emptyConstantIdentifierPrivateIndex())
   , cd(emptyConstantIdentifierPrivate())
 {
 }
 
 Identifier& Identifier::operator=(const Identifier& rhs)
 {
   if(dd == rhs.dd && cd == rhs.cd)
     return *this;
 
   if(!m_index)
     delete dd;
   dd = nullptr;
 
   rhs.makeConstant();
   cd = rhs.cd;
   m_index = rhs.m_index;
   Q_ASSERT(cd);
   return *this;
 }
 
 Identifier::Identifier(Identifier&& rhs) Q_DECL_NOEXCEPT
   : m_index(rhs.m_index)
 {
   if (m_index) {
     cd = rhs.cd;
   } else {
     dd = rhs.dd;
   }
   rhs.cd = emptyConstantIdentifierPrivate();
   rhs.m_index = emptyConstantIdentifierPrivateIndex();
 }
 
 Identifier& Identifier::operator=(Identifier&& rhs) Q_DECL_NOEXCEPT
 {
   if(dd == rhs.dd && cd == rhs.cd)
     return *this;
 
   if (!m_index) {
     delete dd;
     dd = nullptr;
   }
 
   m_index = rhs.m_index;
 
   if (m_index) {
     cd = rhs.cd;
   } else {
     dd = rhs.dd;
   }
   rhs.cd = emptyConstantIdentifierPrivate();
   rhs.m_index = emptyConstantIdentifierPrivateIndex();
 
   return *this;
 }
 
 Identifier::~Identifier()
 {
   if(!m_index)
     delete dd;
 }
 
 bool Identifier::nameEquals(const Identifier& rhs) const
 {
   return identifier() == rhs.identifier();
 }
 
 uint Identifier::hash() const
 {
   if(!m_index)
     return dd->hash();
   else
     return cd->hash();
 }
 
 bool Identifier::isEmpty() const
 {
   if(!m_index)
     return dd->m_identifier.isEmpty() && dd->m_unique == 0 && dd->templateIdentifiersSize() == 0;
   else
     return cd->m_identifier.isEmpty() && cd->m_unique == 0 && cd->templateIdentifiersSize() == 0;
 }
 
 Identifier Identifier::unique(int token)
 {
   Identifier ret;
   ret.setUnique(token);
   return ret;
 }
 
 bool Identifier::isUnique() const
 {
   if(!m_index)
     return dd->m_unique;
   else
     return cd->m_unique;
 }
 
 int Identifier::uniqueToken() const
 {
   if(!m_index)
     return dd->m_unique;
   else
     return cd->m_unique;
 }
 
 void Identifier::setUnique(int token)
 {
   if (token != uniqueToken()) {
     prepareWrite();
     dd->m_unique = token;
   }
 }
 
 const IndexedString Identifier::identifier() const
 {
   if(!m_index)
     return dd->m_identifier;
   else
     return cd->m_identifier;
 }
 
 void Identifier::setIdentifier(const QString& identifier)
 {
   IndexedString id(identifier);
   if (id != this->identifier()) {
     prepareWrite();
     dd->m_identifier = std::move(id);
   }
 }
 
 void Identifier::setIdentifier(const IndexedString& identifier)
 {
   if (identifier != this->identifier()) {
     prepareWrite();
     dd->m_identifier = identifier;
   }
 }
 
 IndexedTypeIdentifier Identifier::templateIdentifier(int num) const
 {
   if(!m_index)
     return dd->templateIdentifiers()[num];
   else
     return cd->templateIdentifiers()[num];
 }
 
 uint Identifier::templateIdentifiersCount() const
 {
   if(!m_index)
     return dd->templateIdentifiersSize();
   else
     return cd->templateIdentifiersSize();
 }
 
 void Identifier::appendTemplateIdentifier(const IndexedTypeIdentifier& identifier)
 {
   prepareWrite();
   dd->templateIdentifiersList.append(identifier);
 }
 
 void Identifier::clearTemplateIdentifiers()
 {
   prepareWrite();
   dd->templateIdentifiersList.clear();
 }
 
 uint Identifier::index() const
 {
   makeConstant();
   Q_ASSERT(m_index);
   return m_index;
 }
 
 bool Identifier::inRepository() const
 {
   return m_index;
 }
 
 void Identifier::setTemplateIdentifiers(const QList<IndexedTypeIdentifier>& templateIdentifiers)
 {
   prepareWrite();
   dd->templateIdentifiersList.clear();
   for (const IndexedTypeIdentifier& id : templateIdentifiers) {
     dd->templateIdentifiersList.append(id);
   }
 }
 
 QString Identifier::toString(IdentifierStringFormattingOptions options) const
 {
   QString ret = identifier().str();
 
   if (!options.testFlag(RemoveTemplateInformation) && templateIdentifiersCount()) {
     QStringList templateIds;
     templateIds.reserve(templateIdentifiersCount());
     for (uint i = 0; i < templateIdentifiersCount(); ++i) {
       templateIds.append(templateIdentifier(i).toString(options));
     }
     ret += QStringLiteral("< ") + templateIds.join(QStringLiteral(", ")) + QStringLiteral(" >");
   }
 
   return ret;
 }
 
 bool Identifier::operator==(const Identifier& rhs) const
 {
   return index() == rhs.index();
 }
 
 bool Identifier::operator!=(const Identifier& rhs) const
 {
   return !operator==(rhs);
 }
 
 uint QualifiedIdentifier::index() const
 {
   makeConstant();
   Q_ASSERT(m_index);
   return m_index;
 }
 
 void Identifier::makeConstant() const
 {
   if(m_index)
     return;
   m_index = identifierRepository()->index( IdentifierItemRequest(*dd) );
   delete dd;
   cd = identifierRepository()->itemFromIndex( m_index );
 }
 
 void Identifier::prepareWrite()
 {
   if(m_index) {
     const IdentifierPrivate<false>* oldCc = cd;
     dd = new IdentifierPrivate<true>;
     dd->m_hash = oldCc->m_hash;
     dd->m_unique = oldCc->m_unique;
     dd->m_identifier = oldCc->m_identifier;
     dd->copyListsFrom(*oldCc);
     m_index = 0;
   }
 
   dd->clearHash();
 }
 
 bool QualifiedIdentifier::inRepository() const
 {
   if(m_index)
     return true;
   else
     return (bool)qualifiedidentifierRepository()->findIndex( QualifiedIdentifierItemRequest(*dd) );
 }
 
 QualifiedIdentifier::QualifiedIdentifier(uint index)
   : m_index(index)
   , cd( qualifiedidentifierRepository()->itemFromIndex(index) )
 {
 }
 
 QualifiedIdentifier::QualifiedIdentifier(const QString& id, bool isExpression)
 {
   if (id.isEmpty()) {
     m_index = emptyConstantQualifiedIdentifierPrivateIndex();
     cd = emptyConstantQualifiedIdentifierPrivate();
     return;
   }
 
   m_index = 0;
   dd = new DynamicQualifiedIdentifierPrivate;
 
   if(isExpression) {
     setIsExpression(true);
     if(!id.isEmpty()) {
       //Prevent tokenization, since we may lose information there
       Identifier finishedId;
       finishedId.setIdentifier(id);
       push(finishedId);
     }
   }else{
     if (id.startsWith(QStringLiteral("::"))) {
       dd->m_explicitlyGlobal = true;
       dd->splitIdentifiers(id, 2);
     } else {
       dd->m_explicitlyGlobal = false;
       dd->splitIdentifiers(id, 0);
     }
   }
 }
 
 QualifiedIdentifier::QualifiedIdentifier(const Identifier& id)
 {
   if (id.isEmpty()) {
     m_index = emptyConstantQualifiedIdentifierPrivateIndex();
     cd = emptyConstantQualifiedIdentifierPrivate();
     return;
   }
 
   m_index = 0;
   dd = new DynamicQualifiedIdentifierPrivate;
 
   if (id.dd->m_identifier.str().isEmpty()) {
     dd->m_explicitlyGlobal = true;
   } else {
     dd->m_explicitlyGlobal = false;
     dd->identifiersList.append(IndexedIdentifier(id));
   }
 }
 
 QualifiedIdentifier::QualifiedIdentifier()
   : m_index(emptyConstantQualifiedIdentifierPrivateIndex())
   , cd(emptyConstantQualifiedIdentifierPrivate())
 {
 }
 
 QualifiedIdentifier::QualifiedIdentifier(const QualifiedIdentifier& id)
 {
   if(id.m_index) {
     m_index = id.m_index;
     cd = id.cd;
   }else{
     m_index = 0;
     dd = new QualifiedIdentifierPrivate<true>(*id.dd);
   }
 }
 
 QualifiedIdentifier::QualifiedIdentifier(QualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT
   : m_index(rhs.m_index)
 {
   if (m_index) {
     cd = rhs.cd;
   } else {
     dd = rhs.dd;
   }
   rhs.m_index = emptyConstantQualifiedIdentifierPrivateIndex();
   rhs.cd = emptyConstantQualifiedIdentifierPrivate();
 }
 
 QualifiedIdentifier& QualifiedIdentifier::operator=(const QualifiedIdentifier& rhs)
 {
   if(dd == rhs.dd && cd == rhs.cd)
     return *this;
 
   if(!m_index)
     delete dd;
   rhs.makeConstant();
   cd = rhs.cd;
   m_index = rhs.m_index;
   return *this;
 }
 
 QualifiedIdentifier& QualifiedIdentifier::operator=(QualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT
 {
   if(!m_index)
     delete dd;
   m_index = rhs.m_index;
   if (m_index) {
     cd = rhs.cd;
   } else {
     dd = rhs.dd;
   }
   rhs.cd = emptyConstantQualifiedIdentifierPrivate();
   rhs.m_index = emptyConstantQualifiedIdentifierPrivateIndex();
   return *this;
 }
 
 QualifiedIdentifier::~QualifiedIdentifier()
 {
   if(!m_index)
     delete dd;
 }
 
 QStringList QualifiedIdentifier::toStringList(IdentifierStringFormattingOptions options) const
 {
   QStringList ret;
   ret.reserve(explicitlyGlobal() + count());
   if (explicitlyGlobal())
     ret.append(QString());
 
   if(m_index) {
     ret.reserve(ret.size() + cd->identifiersSize());
     FOREACH_FUNCTION_STATIC(const IndexedIdentifier& index, cd->identifiers)
       ret << index.identifier().toString(options);
   }else{
     ret.reserve(ret.size() + dd->identifiersSize());
     FOREACH_FUNCTION_STATIC(const IndexedIdentifier& index, dd->identifiers)
       ret << index.identifier().toString(options);
   }
 
   return ret;
 }
 
 QString QualifiedIdentifier::toString(IdentifierStringFormattingOptions options) const
 {
   const QString doubleColon = QStringLiteral("::");
 
   QString ret;
   if( !options.testFlag(RemoveExplicitlyGlobalPrefix) && explicitlyGlobal() )
     ret = doubleColon;
 
   QStringList identifiers;
   if(m_index) {
     identifiers.reserve(cd->identifiersSize());
     FOREACH_FUNCTION_STATIC(const IndexedIdentifier& index, cd->identifiers)
     {
       identifiers += index.identifier().toString(options);
     }
   }else{
     identifiers.reserve(dd->identifiersSize());
     FOREACH_FUNCTION_STATIC(const IndexedIdentifier& index, dd->identifiers)
     {
       identifiers += index.identifier().toString(options);
     }
   }
 
   return ret + identifiers.join(doubleColon);
 }
 
 QualifiedIdentifier QualifiedIdentifier::merge(const QualifiedIdentifier& base) const
 {
   QualifiedIdentifier ret(base);
   ret.push(*this);
   return ret;
 }
 
 QualifiedIdentifier QualifiedIdentifier::operator+(const QualifiedIdentifier& rhs) const
 {
   return rhs.merge(*this);
 }
 
 QualifiedIdentifier& QualifiedIdentifier::operator+=(const QualifiedIdentifier& rhs)
 {
   push(rhs);
   return *this;
 }
 
 QualifiedIdentifier QualifiedIdentifier::operator+(const Identifier& rhs) const
 {
   QualifiedIdentifier ret(*this);
   ret.push(rhs);
   return ret;
 }
 
 QualifiedIdentifier& QualifiedIdentifier::operator+=(const Identifier& rhs)
 {
   push(rhs);
   return *this;
 }
 
 QualifiedIdentifier QualifiedIdentifier::operator+(const IndexedIdentifier& rhs) const
 {
   QualifiedIdentifier ret(*this);
   ret.push(rhs);
   return ret;
 }
 
 QualifiedIdentifier& QualifiedIdentifier::operator+=(const IndexedIdentifier& rhs)
 {
   push(rhs);
   return *this;
 }
 
 bool QualifiedIdentifier::isExpression() const
 {
   if(m_index)
     return cd->m_isExpression;
   else
     return dd->m_isExpression;
 }
 
 void QualifiedIdentifier::setIsExpression(bool is)
 {
   if (is != isExpression()) {
     prepareWrite();
     dd->m_isExpression = is;
   }
 }
 
 bool QualifiedIdentifier::explicitlyGlobal() const
 {
   // True if started with "::"
   if(m_index)
     return cd->m_explicitlyGlobal;
   else
     return dd->m_explicitlyGlobal;
 }
 
 void QualifiedIdentifier::setExplicitlyGlobal(bool eg)
 {
   if (eg != explicitlyGlobal()) {
     prepareWrite();
     dd->m_explicitlyGlobal = eg;
   }
 }
 
 bool QualifiedIdentifier::sameIdentifiers(const QualifiedIdentifier& rhs) const
 {
   if(m_index && rhs.m_index)
     return cd->listsEqual(*rhs.cd);
   else if(m_index && !rhs.m_index)
     return cd->listsEqual(*rhs.dd);
   else if(!m_index && !rhs.m_index)
     return dd->listsEqual(*rhs.dd);
   else
     return dd->listsEqual(*rhs.cd);
 }
 
 bool QualifiedIdentifier::operator==(const QualifiedIdentifier& rhs) const
 {
   if( cd == rhs.cd )
     return true;
   return hash() == rhs.hash() && sameIdentifiers(rhs);
 }
 
 bool QualifiedIdentifier::operator!=(const QualifiedIdentifier& rhs) const
 {
   return !operator==(rhs);
 }
 
 bool QualifiedIdentifier::beginsWith(const QualifiedIdentifier& other) const
 {
   uint c = count();
   uint oc = other.count();
 
   for (uint i = 0; i < c && i < oc; ++i)
     if (at(i) == other.at(i)) {
       continue;
     } else {
       return false;
     }
 
   return true;
 }
 
 struct Visitor
 {
   Visitor(KDevVarLengthArray<QualifiedIdentifier>& target, uint hash)
     : target(target)
     , hash(hash)
   {
   }
 
   bool operator()(const ConstantQualifiedIdentifierPrivate* item, uint index) const
   {
     if(item->m_hash == hash)
       target.append(QualifiedIdentifier(index));
     return true;
   }
 
   KDevVarLengthArray<QualifiedIdentifier>& target;
   const uint hash;
 };
 
 uint QualifiedIdentifier::hash() const
 {
   if(m_index)
     return cd->hash();
   else
     return dd->hash();
 }
 
 uint qHash(const IndexedTypeIdentifier& id)
 {
   return id.hash();
 }
 
 uint qHash(const QualifiedIdentifier& id)
 {
   return id.hash();
 }
 
 uint qHash(const Identifier& id)
 {
   return id.hash();
 }
 
 bool QualifiedIdentifier::isQualified() const
 {
   return count() > 1 || explicitlyGlobal();
 }
 
 void QualifiedIdentifier::push(const Identifier& id)
 {
   if(id.isEmpty())
     return;
 
   push(IndexedIdentifier(id));
 }
 
 void QualifiedIdentifier::push(const IndexedIdentifier& id)
 {
   if (id.isEmpty()) {
     return;
   }
 
   prepareWrite();
 
   dd->identifiersList.append(id);
 }
 
 void QualifiedIdentifier::push(const QualifiedIdentifier& id)
 {
   if (id.isEmpty()) {
     return;
   }
 
   prepareWrite();
 
   if (id.m_index) {
     dd->identifiersList.append(id.cd->identifiers(), id.cd->identifiersSize());
   } else {
     dd->identifiersList.append(id.dd->identifiers(), id.dd->identifiersSize());
   }
 
   if (id.explicitlyGlobal()) {
     setExplicitlyGlobal(true);
   }
 }
 
 void QualifiedIdentifier::pop()
 {
   prepareWrite();
   if(!dd->identifiersSize())
     return;
   dd->identifiersList.resize(dd->identifiersList.size()-1);
 }
 
 void QualifiedIdentifier::clear()
 {
   prepareWrite();
   dd->identifiersList.clear();
   dd->m_explicitlyGlobal = false;
   dd->m_isExpression = false;
 }
 
 
 bool QualifiedIdentifier::isEmpty() const
 {
   if(m_index)
     return cd->identifiersSize() == 0;
   else
     return dd->identifiersSize() == 0;
 }
 
 int QualifiedIdentifier::count() const
 {
   if(m_index)
     return cd->identifiersSize();
   else
     return dd->identifiersSize();
 }
 
 Identifier QualifiedIdentifier::first() const
 {
   return indexedFirst().identifier();
 }
 
 IndexedIdentifier QualifiedIdentifier::indexedFirst() const
 {
   if( (m_index && cd->identifiersSize() == 0) || (!m_index && dd->identifiersSize() == 0) )
     return IndexedIdentifier();
   else
     return indexedAt(0);
 }
 
 Identifier QualifiedIdentifier::last() const
 {
   return indexedLast().identifier();
 }
 
 IndexedIdentifier QualifiedIdentifier::indexedLast() const
 {
   uint c = count();
   if(c)
     return indexedAt(c-1);
   else
     return IndexedIdentifier();
 }
 
 Identifier QualifiedIdentifier::top() const
 {
   return last();
 }
 
 QualifiedIdentifier QualifiedIdentifier::mid(int pos, int len) const
 {
   QualifiedIdentifier ret;
   if( pos == 0 )
     ret.setExplicitlyGlobal(explicitlyGlobal());
 
   int cnt = (int)count();
 
   if( len == -1 )
     len = cnt - pos;
 
   if( pos+len > cnt )
     len -= cnt - (pos+len);
 
   for( int a = pos; a < pos+len; a++ )
     ret.push(at(a));
 
   return ret;
 }
 
 Identifier QualifiedIdentifier::at(int i) const
 {
   return indexedAt(i).identifier();
 }
 
 IndexedIdentifier QualifiedIdentifier::indexedAt(int i) const
 {
   if (m_index) {
     Q_ASSERT(i >= 0 && i < (int)cd->identifiersSize());
     return cd->identifiers()[i];
   } else {
     Q_ASSERT(i >= 0 && i < (int)dd->identifiersSize());
     return dd->identifiers()[i];
   }
 }
 
 void QualifiedIdentifier::makeConstant() const
 {
   if(m_index)
     return;
   m_index = qualifiedidentifierRepository()->index( QualifiedIdentifierItemRequest(*dd) );
   delete dd;
   cd = qualifiedidentifierRepository()->itemFromIndex( m_index );
 }
 
 void QualifiedIdentifier::prepareWrite()
 {
 
   if(m_index) {
     const QualifiedIdentifierPrivate<false>* oldCc = cd;
     dd = new QualifiedIdentifierPrivate<true>;
     dd->m_explicitlyGlobal = oldCc->m_explicitlyGlobal;
     dd->m_isExpression = oldCc->m_isExpression;
     dd->m_hash = oldCc->m_hash;
 
     dd->copyListsFrom(*oldCc);
     m_index = 0;
   }
 
   dd->clearHash();
 }
 
 uint IndexedTypeIdentifier::hash() const
 {
     quint32 bitfields = static_cast<quint32>(m_isConstant)
       | (m_isReference << 1)
       | (m_isRValue << 2)
       | (m_isVolatile << 3)
       | (m_pointerDepth << 4)
       | (m_pointerConstMask << 9);
-    return KDevHash() << m_identifier.getIndex() << bitfields;
+    return KDevHash() << m_identifier.index() << bitfields;
 }
 
 bool IndexedTypeIdentifier::operator==(const IndexedTypeIdentifier& rhs) const
 {
     return m_identifier == rhs.m_identifier
         && m_isConstant == rhs.m_isConstant
         && m_isReference == rhs.m_isReference
         && m_isRValue == rhs.m_isRValue
         && m_isVolatile == rhs.m_isVolatile
         && m_pointerConstMask == rhs.m_pointerConstMask
         && m_pointerDepth == rhs.m_pointerDepth;
 }
 
 bool IndexedTypeIdentifier::operator!=(const IndexedTypeIdentifier& rhs) const
 {
   return !operator==(rhs);
 }
 
 bool IndexedTypeIdentifier::isReference() const
 {
   return m_isReference;
 }
 
 void IndexedTypeIdentifier::setIsReference(bool isRef)
 {
   m_isReference = isRef;
 }
 
 bool IndexedTypeIdentifier::isRValue() const
 {
   return m_isRValue;
 }
 
 void IndexedTypeIdentifier::setIsRValue(bool isRVal)
 {
   m_isRValue = isRVal;
 }
 
 bool IndexedTypeIdentifier::isConstant() const
 {
   return m_isConstant;
 }
 
 void IndexedTypeIdentifier::setIsConstant(bool isConst)
 {
   m_isConstant = isConst;
 }
 
 bool IndexedTypeIdentifier::isVolatile() const
 {
   return m_isVolatile;
 }
 
 void IndexedTypeIdentifier::setIsVolatile(bool isVolatile)
 {
   m_isVolatile = isVolatile;
 }
 
 int IndexedTypeIdentifier::pointerDepth() const
 {
   return m_pointerDepth;
 }
 
 void IndexedTypeIdentifier::setPointerDepth(int depth)
 {
   Q_ASSERT(depth <= 23 && depth >= 0);
   ///Clear the mask in removed fields
   for(int s = depth; s < (int)m_pointerDepth; ++s)
     setIsConstPointer(s, false);
 
   m_pointerDepth = depth;
 }
 
 bool IndexedTypeIdentifier::isConstPointer(int depthNumber) const
 {
   return m_pointerConstMask & (1 << depthNumber);
 }
 
 void IndexedTypeIdentifier::setIsConstPointer(int depthNumber, bool constant)
 {
   if(constant)
     m_pointerConstMask |= (1 << depthNumber);
   else
     m_pointerConstMask &= (~(1 << depthNumber));
 }
 
 QString IndexedTypeIdentifier::toString(IdentifierStringFormattingOptions options) const
 {
   QString ret;
   if(isConstant())
     ret += QLatin1String("const ");
   if(isVolatile())
     ret += QLatin1String("volatile ");
 
   ret += m_identifier.identifier().toString(options);
   for(int a = 0; a < pointerDepth(); ++a) {
     ret += QLatin1Char('*');
     if( isConstPointer(a) )
       ret += QLatin1String("const");
   }
 
   if(isRValue())
     ret += QLatin1String("&&");
   else if(isReference())
     ret += QLatin1Char('&');
   return ret;
 }
 
 IndexedTypeIdentifier::IndexedTypeIdentifier(const IndexedQualifiedIdentifier& identifier)
   : m_identifier(identifier)
   , m_isConstant(false)
   , m_isReference(false)
   , m_isRValue(false)
   , m_isVolatile(false)
   , m_pointerDepth(0)
   , m_pointerConstMask(0)
 { }
 
 IndexedTypeIdentifier::IndexedTypeIdentifier(const QString& identifier, bool isExpression)
   : m_identifier(QualifiedIdentifier(identifier, isExpression))
   , m_isConstant(false)
   , m_isReference(false)
   , m_isRValue(false)
   , m_isVolatile(false)
   , m_pointerDepth(0)
   , m_pointerConstMask(0)
 { }
 
 IndexedIdentifier::IndexedIdentifier()
-  : index(emptyConstantIdentifierPrivateIndex())
+  : m_index(emptyConstantIdentifierPrivateIndex())
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedIdentifier::IndexedIdentifier(const Identifier& id)
-  : index(id.index())
+  : m_index(id.index())
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedIdentifier::IndexedIdentifier(const IndexedIdentifier& rhs)
-  : index(rhs.index)
+  : m_index(rhs.m_index)
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedIdentifier::IndexedIdentifier(IndexedIdentifier&& rhs) Q_DECL_NOEXCEPT
-  : index(rhs.index)
+  : m_index(rhs.m_index)
 {
-  rhs.index = emptyConstantIdentifierPrivateIndex();
+  rhs.m_index = emptyConstantIdentifierPrivateIndex();
 }
 
 IndexedIdentifier::~IndexedIdentifier()
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedIdentifier& IndexedIdentifier::operator=(const Identifier& id)
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 
-  index = id.index();
+  m_index = id.index();
 
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
   return *this;
 }
 
 IndexedIdentifier& IndexedIdentifier::operator=(IndexedIdentifier&& rhs) Q_DECL_NOEXCEPT
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "decreasing"; )
 
-    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   } else if (shouldDoDUChainReferenceCounting(&rhs)) {
     QMutexLocker lock(identifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "decreasing"; )
 
-    decrease(identifierRepository()->dynamicItemFromIndexSimple(rhs.index)->m_refCount, rhs.index);
+    decrease(identifierRepository()->dynamicItemFromIndexSimple(rhs.m_index)->m_refCount, rhs.m_index);
   }
 
-  index = rhs.index;
-  rhs.index = emptyConstantIdentifierPrivateIndex();
+  m_index = rhs.m_index;
+  rhs.m_index = emptyConstantIdentifierPrivateIndex();
 
   if(shouldDoDUChainReferenceCounting(this) && !(shouldDoDUChainReferenceCounting(&rhs))) {
     QMutexLocker lock(identifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "increasing"; )
 
-    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 
   return *this;
 }
 
 IndexedIdentifier& IndexedIdentifier::operator=(const IndexedIdentifier& id)
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    decrease(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 
-  index = id.index;
+  m_index = id.m_index;
 
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(identifierRepository()->mutex());
-    increase(identifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(identifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
   return *this;
 }
 
 bool IndexedIdentifier::operator==(const IndexedIdentifier& rhs) const
 {
-  return index == rhs.index;
+  return m_index == rhs.m_index;
 }
 
 bool IndexedIdentifier::operator!=(const IndexedIdentifier& rhs) const
 {
-  return index != rhs.index;
+  return m_index != rhs.m_index;
 }
 
 bool IndexedIdentifier::operator==(const Identifier& id) const
 {
-  return index == id.index();
+  return m_index == id.index();
 }
 
 Identifier IndexedIdentifier::identifier() const
 {
-  return Identifier(index);
+  return Identifier(m_index);
 }
 
 IndexedIdentifier::operator Identifier() const
 {
-  return Identifier(index);
+  return Identifier(m_index);
 }
 
 bool IndexedQualifiedIdentifier::isValid() const
 {
-  return index != emptyConstantQualifiedIdentifierPrivateIndex();
+  return m_index != emptyConstantQualifiedIdentifierPrivateIndex();
 }
 
 bool IndexedQualifiedIdentifier::isEmpty() const
 {
-  return index == emptyConstantQualifiedIdentifierPrivateIndex();
+  return m_index == emptyConstantQualifiedIdentifierPrivateIndex();
 }
 
 int cnt = 0;
 
 IndexedQualifiedIdentifier IndexedTypeIdentifier::identifier() const
 {
   return m_identifier;
 }
 
 
 void IndexedTypeIdentifier::setIdentifier(const IndexedQualifiedIdentifier& id)
 {
   m_identifier = id;
 }
 
 IndexedQualifiedIdentifier::IndexedQualifiedIdentifier()
-  : index(emptyConstantQualifiedIdentifierPrivateIndex())
+  : m_index(emptyConstantQualifiedIdentifierPrivateIndex())
 {
-  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << index; )
+  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << m_index; )
 
   if(shouldDoDUChainReferenceCounting(this)) {
     ifDebug( qCDebug(LANGUAGE) << "increasing"; )
 
     //qCDebug(LANGUAGE) << "(" << ++cnt << ")" << this << identifier().toString() << "inc" << index;
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
-    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedQualifiedIdentifier::IndexedQualifiedIdentifier(const QualifiedIdentifier& id)
-  : index(id.index())
+  : m_index(id.index())
 {
-  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << index; )
+  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << m_index; )
 
   if(shouldDoDUChainReferenceCounting(this)) {
     ifDebug( qCDebug(LANGUAGE) << "increasing"; )
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
-    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedQualifiedIdentifier::IndexedQualifiedIdentifier(const IndexedQualifiedIdentifier& id)
-  : index(id.index)
+  : m_index(id.m_index)
 {
-  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << index; )
+  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << m_index; )
 
   if(shouldDoDUChainReferenceCounting(this)) {
     ifDebug( qCDebug(LANGUAGE) << "increasing"; )
 
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
-    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 IndexedQualifiedIdentifier::IndexedQualifiedIdentifier(IndexedQualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT
-  : index(rhs.index)
+  : m_index(rhs.m_index)
 {
-  rhs.index = emptyConstantQualifiedIdentifierPrivateIndex();
+  rhs.m_index = emptyConstantQualifiedIdentifierPrivateIndex();
 }
 
 IndexedQualifiedIdentifier& IndexedQualifiedIdentifier::operator=(const QualifiedIdentifier& id)
 {
-  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << index; )
+  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << m_index; )
 
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
 
     ifDebug( qCDebug(LANGUAGE) << "decreasing"; )
-    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
 
-    index = id.index();
+    m_index = id.index();
 
-    ifDebug( qCDebug(LANGUAGE) << index << "increasing"; )
-    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    ifDebug( qCDebug(LANGUAGE) << m_index << "increasing"; )
+    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   } else {
-    index = id.index();
+    m_index = id.index();
   }
 
   return *this;
 }
 
 IndexedQualifiedIdentifier& IndexedQualifiedIdentifier::operator=(const IndexedQualifiedIdentifier& rhs)
 {
 
-  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << index; )
+  ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << m_index; )
 
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "decreasing"; )
 
-    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
 
-    index = rhs.index;
+    m_index = rhs.m_index;
 
-    ifDebug( qCDebug(LANGUAGE) << index << "increasing"; )
-    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    ifDebug( qCDebug(LANGUAGE) << m_index << "increasing"; )
+    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   } else {
-    index = rhs.index;
+    m_index = rhs.m_index;
   }
 
   return *this;
 }
 
 IndexedQualifiedIdentifier& IndexedQualifiedIdentifier::operator=(IndexedQualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT
 {
   if(shouldDoDUChainReferenceCounting(this)) {
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "decreasing"; )
 
-    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   } else if (shouldDoDUChainReferenceCounting(&rhs)) {
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "decreasing"; )
 
-    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(rhs.index)->m_refCount, rhs.index);
+    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(rhs.m_index)->m_refCount, rhs.m_index);
   }
 
-  index = rhs.index;
-  rhs.index = emptyConstantQualifiedIdentifierPrivateIndex();
+  m_index = rhs.m_index;
+  rhs.m_index = emptyConstantQualifiedIdentifierPrivateIndex();
 
   if(shouldDoDUChainReferenceCounting(this) && !(shouldDoDUChainReferenceCounting(&rhs))) {
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
     ifDebug( qCDebug(LANGUAGE) << "increasing"; )
 
-    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    increase(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 
   return *this;
 }
 
 IndexedQualifiedIdentifier::~IndexedQualifiedIdentifier()
 {
   ifDebug( qCDebug(LANGUAGE) << "(" << ++cnt << ")" << identifier().toString() << index; )
   if(shouldDoDUChainReferenceCounting(this)) {
     ifDebug( qCDebug(LANGUAGE) << index << "decreasing"; )
     QMutexLocker lock(qualifiedidentifierRepository()->mutex());
-    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(index)->m_refCount, index);
+    decrease(qualifiedidentifierRepository()->dynamicItemFromIndexSimple(m_index)->m_refCount, m_index);
   }
 }
 
 bool IndexedQualifiedIdentifier::operator==(const IndexedQualifiedIdentifier& rhs) const
 {
-  return index == rhs.index;
+  return m_index == rhs.m_index;
 }
 
 bool IndexedQualifiedIdentifier::operator==(const QualifiedIdentifier& id) const
 {
-  return index == id.index();
+  return m_index == id.index();
 }
 
 QualifiedIdentifier IndexedQualifiedIdentifier::identifier() const
 {
-  return QualifiedIdentifier(index);
+  return QualifiedIdentifier(m_index);
 }
 
 IndexedQualifiedIdentifier::operator QualifiedIdentifier() const
 {
-  return QualifiedIdentifier(index);
+  return QualifiedIdentifier(m_index);
 }
 
 void initIdentifierRepository() {
   emptyConstantIdentifierPrivateIndex();
   emptyConstantIdentifierPrivate();
   emptyConstantQualifiedIdentifierPrivateIndex();
   emptyConstantQualifiedIdentifierPrivate();
 }
 
 }
 
 QDebug operator<<(QDebug s, const KDevelop::Identifier& identifier)
 {
   s.nospace() << identifier.toString();
   return s.space();
 }
 
 QDebug operator<<(QDebug s, const KDevelop::QualifiedIdentifier& identifier)
 {
   s.nospace() << identifier.toString();
   return s.space();
 }
diff --git a/kdevplatform/language/duchain/identifier.h b/kdevplatform/language/duchain/identifier.h
index d0653b7329..0441ae22c2 100644
--- a/kdevplatform/language/duchain/identifier.h
+++ b/kdevplatform/language/duchain/identifier.h
@@ -1,484 +1,484 @@
 /* This file is part of KDevelop
     Copyright 2006 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_IDENTIFIER_H
 #define KDEVPLATFORM_IDENTIFIER_H
 
 #include <QList>
 #include <QMetaType>
 #include <util/kdevvarlengtharray.h>
 
 #include <language/languageexport.h>
 #include <serialization/referencecounting.h>
 
 //We use shared d-pointers, which is even better than a d-pointer, but krazy probably won't get it, so exclude the test.
 //krazy:excludeall=dpointer
 
 class QStringList;
 
 namespace KDevelop
 {
 
 class IndexedTypeIdentifier;
 class Identifier;
 class QualifiedIdentifier;
 template<bool>
 class QualifiedIdentifierPrivate;
 template<bool>
 class IdentifierPrivate;
 class IndexedString;
 
 /**
  * A helper-class to store an identifier by index in a type-safe way.
  *
  * The difference to Identifier is that this class only stores the index of an identifier that is in the repository, without any dynamic
  * abilities or access to the contained data.
  *
  * This class does "disk reference counting"
  *
  * @warning Do not use this after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT IndexedIdentifier : public ReferenceCountManager
 {
 public:
   IndexedIdentifier();
   explicit IndexedIdentifier(const Identifier& id);
   IndexedIdentifier(const IndexedIdentifier& rhs);
   IndexedIdentifier(IndexedIdentifier&& rhs) Q_DECL_NOEXCEPT;
   IndexedIdentifier& operator=(const Identifier& id);
   IndexedIdentifier& operator=(const IndexedIdentifier& rhs);
   IndexedIdentifier& operator=(IndexedIdentifier&& rhs) Q_DECL_NOEXCEPT;
   ~IndexedIdentifier();
   bool operator==(const IndexedIdentifier& rhs) const;
   bool operator!=(const IndexedIdentifier& rhs) const;
   bool operator==(const Identifier& id) const;
 
   bool isEmpty() const;
 
   Identifier identifier() const;
   operator Identifier() const;
 
-  uint getIndex() const
+  unsigned int index() const
   {
-    return index;
+    return m_index;
   }
 
 private:
-  unsigned int index;
+  unsigned int m_index;
 };
 
 /**
  * A helper-class to store an identifier by index in a type-safe way.
  *
  * The difference to QualifiedIdentifier is that this class only stores the index of an identifier that is in the repository, without any dynamic
  * abilities or access to the contained data.
  *
  * This class does "disk reference counting"
  *
  * @warning Do not use this after QCoreApplication::aboutToQuit() has been emitted, items that are not disk-referenced will be invalid at that point.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT IndexedQualifiedIdentifier : public ReferenceCountManager
 {
 public:
   IndexedQualifiedIdentifier();
   IndexedQualifiedIdentifier(const QualifiedIdentifier& id);
   IndexedQualifiedIdentifier(const IndexedQualifiedIdentifier& rhs);
   IndexedQualifiedIdentifier(IndexedQualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
   IndexedQualifiedIdentifier& operator=(const QualifiedIdentifier& id);
   IndexedQualifiedIdentifier& operator=(const IndexedQualifiedIdentifier& id);
   IndexedQualifiedIdentifier& operator=(IndexedQualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
   ~IndexedQualifiedIdentifier();
   bool operator==(const IndexedQualifiedIdentifier& rhs) const;
   bool operator==(const QualifiedIdentifier& id) const;
 
   bool operator<(const IndexedQualifiedIdentifier& rhs) const
   {
-    return index < rhs.index;
+    return m_index < rhs.m_index;
   }
 
   bool isValid() const;
   bool isEmpty() const;
 
   QualifiedIdentifier identifier() const;
   operator QualifiedIdentifier() const;
 
-  uint getIndex() const
+  unsigned int index() const
   {
-    return index;
+    return m_index;
   }
 
 private:
-  uint index;
+  unsigned int m_index;
 };
 
 /**
  * Flags to control the string representation of identifiers.
  */
 enum IdentifierStringFormattingOption {
   NoOptions = 0x0,
 
   /// Removes explicit global prefix from the result.
   /// When enabled, global identifiers will be formatted as "globalIdentifierFormattedString"
   /// instead "::globalIdentifierFormattedString".
   RemoveExplicitlyGlobalPrefix = 0x1,
 
   /// Removes template information from the result.
   /// When enabled, TemplateClass< someDataType > will be formatted as plain "TemplateClass".
   RemoveTemplateInformation = 0x2
 };
 Q_DECLARE_FLAGS(IdentifierStringFormattingOptions, IdentifierStringFormattingOption)
 
 /**
  * Represents a single unqualified identifier
  */
 class KDEVPLATFORMLANGUAGE_EXPORT Identifier
 {
   friend class QualifiedIdentifier;
 
 public:
   /**
    * @param start The position in the given string where to start searching for the identifier. (optional)
    * @param takenRange If this is nonzero, it will be filled with the length of the range from the beginning
    *                   of the given string, that was used to construct this identifier. (optional)
    *
    * @warning The identifier is parsed in a C++-similar way, and the result may not be what you expect.
    *          If you want to prevent that parsing, use the constructor that takes IndexedString.
    */
   explicit Identifier(const QString& str, uint start = 0, uint* takenRange = nullptr);
   /**
    * Preferred constructor, use this if you already have an IndexedString available. This does not decompose the given string.
    */
   explicit Identifier(const IndexedString& str);
   Identifier(const Identifier& rhs);
   explicit Identifier(uint index);
   Identifier();
   Identifier(Identifier&& rhs) Q_DECL_NOEXCEPT;
   ~Identifier();
   Identifier& operator=(const Identifier& rhs);
   Identifier& operator=(Identifier&& rhs) Q_DECL_NOEXCEPT;
 
   static Identifier unique(int token);
 
   bool isUnique() const;
   int uniqueToken() const;
   /**
    * If \a token is non-zero, turns this Identifier into the special per-document unique identifier.
    *
    * This is used e.g. for anonymous namespaces.
    *
    * Pass a token which is specific to the document to allow correct equality comparison.
    */
   void setUnique(int token);
 
   const IndexedString identifier() const;
   void setIdentifier(const QString& identifier);
   /**
    * Should be preferred over the other version
    */
   void setIdentifier(const IndexedString& identifier);
 
   uint hash() const;
 
   /**
    * Comparison ignoring the template-identifiers
    */
   bool nameEquals(const Identifier& rhs) const;
 
   /**
    * @warning This is expensive.
    */
   IndexedTypeIdentifier templateIdentifier(int num) const;
   uint templateIdentifiersCount() const;
   void appendTemplateIdentifier(const IndexedTypeIdentifier& identifier);
   void clearTemplateIdentifiers();
   void setTemplateIdentifiers(const QList<IndexedTypeIdentifier>& templateIdentifiers);
 
   QString toString(IdentifierStringFormattingOptions options = NoOptions) const;
 
   bool operator==(const Identifier& rhs) const;
   bool operator!=(const Identifier& rhs) const;
 
   bool isEmpty() const;
 
   /**
    * @return a unique index within the global identifier repository for this identifier.
    *
    * If the identifier isn't in the repository yet, it is added to the repository.
    */
   uint index() const;
 
   bool inRepository() const;
 private:
   void makeConstant() const;
   void prepareWrite();
 
   //Only one of the following pointers is valid at a given time
   mutable uint m_index; //Valid if cd is valid
   union {
     mutable IdentifierPrivate<true>* dd; //Dynamic, owned by this identifier
     mutable const IdentifierPrivate<false>* cd; //Constant, owned by the repository
   };
 };
 
 /**
  * Represents a qualified identifier
  *
  * QualifiedIdentifier has it's hash-values stored, so using the hash-values is very efficient.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT QualifiedIdentifier
 {
 public:
   explicit QualifiedIdentifier(const QString& id, bool isExpression = false);
   explicit QualifiedIdentifier(const Identifier& id);
   QualifiedIdentifier(const QualifiedIdentifier& id);
   explicit QualifiedIdentifier(uint index);
   QualifiedIdentifier();
   QualifiedIdentifier(QualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
   ~QualifiedIdentifier();
   QualifiedIdentifier& operator=(const QualifiedIdentifier& rhs);
   QualifiedIdentifier& operator=(QualifiedIdentifier&& rhs) Q_DECL_NOEXCEPT;
 
   /**
    * Append @p id to this qualified identifier.
    */
   void push(const IndexedIdentifier& id);
   /**
    * Append @p id to this qualified identifier.
    *
    * NOTE: If you have an indexed identifier available, use the above method instead.
    */
   void push(const Identifier& id);
   /**
    * Append all identifiers of @p id to this qualified identifier.
    */
   void push(const QualifiedIdentifier& id);
 
   /**
    * Pops one identifier from back:
    */
   void pop();
   void clear();
   bool isEmpty() const;
   int count() const;
   Identifier first() const;
   IndexedIdentifier indexedFirst() const;
   Identifier last() const;
   IndexedIdentifier indexedLast() const;
   Identifier top() const;
   Identifier at(int i) const;
   IndexedIdentifier indexedAt(int i) const;
   /**
    * @param pos Position where to start the copy.
    * @param len If this is -1, the whole following part will be returned.
    */
   QualifiedIdentifier mid(int pos, int len = -1) const;
 
   /**
    * Copy the leftmost \a len number of identifiers.
    *
    * @param len The number of identifiers to copy, or if negative, the number of identifiers to omit from the right
    */
   inline QualifiedIdentifier left(int len) const
   {
     return mid(0, len > 0 ? len : count() + len);
   }
 
   ///@todo Remove this flag
   bool explicitlyGlobal() const;
   void setExplicitlyGlobal(bool eg);
   bool isQualified() const;
 
   /**
    * A flag that can be set by setIsExpression
    */
   bool isExpression() const;
   /**
    * Set the expression-flag, that can be retrieved by isExpression().
    * This flag is not respected while creating the hash-value and while operator==() comparison.
    * It is respected while isSame(..) comparison.
    */
   void setIsExpression(bool);
 
   QString toString(IdentifierStringFormattingOptions options = NoOptions) const;
   QStringList toStringList(IdentifierStringFormattingOptions options = NoOptions) const;
 
   QualifiedIdentifier operator+(const QualifiedIdentifier& rhs) const;
   QualifiedIdentifier& operator+=(const QualifiedIdentifier& rhs);
 
   /**
    * Nicer interfaces to merge
    */
   QualifiedIdentifier operator+(const Identifier& rhs) const;
   QualifiedIdentifier& operator+=(const Identifier& rhs);
 
   QualifiedIdentifier operator+(const IndexedIdentifier& rhs) const;
   QualifiedIdentifier& operator+=(const IndexedIdentifier& rhs);
 
   /**
    * @return a QualifiedIdentifier with this one appended to the other.
    *
    * It is explicitly global if either this or base is.
    */
   QualifiedIdentifier merge(const QualifiedIdentifier& base) const;
 
   /**
    * The comparison-operators do not respect explicitlyGlobal and isExpression, they only respect the real scope.
    * This is for convenient use in hash-tables etc.
    */
   bool operator==(const QualifiedIdentifier& rhs) const;
   bool operator!=(const QualifiedIdentifier& rhs) const;
 
   bool beginsWith(const QualifiedIdentifier& other) const;
 
   uint index() const;
 
   /**
    * @return true if this qualified identifier is already in the persistent identifier repository
    */
   bool inRepository() const;
 
   /**
    * The hash does not respect explicitlyGlobal, only the real scope.
    */
   uint hash() const;
 
 protected:
   bool sameIdentifiers(const QualifiedIdentifier& rhs) const;
 
   void makeConstant() const;
   void prepareWrite();
 
   mutable uint m_index;
   union {
     mutable QualifiedIdentifierPrivate<true>* dd;
     mutable const QualifiedIdentifierPrivate<false>* cd;
   };
 };
 
 /**
  * Extends IndexedQualifiedIdentifier by:
  * - Arbitrary count of pointer-poperators with cv-qualifiers
  * - Reference operator
  * All the properties set here are respected in the hash value.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT IndexedTypeIdentifier
 {
 public:
   /**
    * Variables like pointerDepth, isReference, etc. are not parsed from the string, so this parsing is quite limited.
    */
   explicit IndexedTypeIdentifier(const IndexedQualifiedIdentifier& identifier = IndexedQualifiedIdentifier());
   explicit IndexedTypeIdentifier(const QString& identifer, bool isExpression = false);
 
   bool isReference() const;
   void setIsReference(bool);
 
   bool isRValue() const;
   void setIsRValue(bool);
 
   bool isConstant() const;
   void setIsConstant(bool);
 
   bool isVolatile() const;
   void setIsVolatile(bool);
 
   IndexedQualifiedIdentifier identifier() const ;
 
   void setIdentifier(const IndexedQualifiedIdentifier& id);
 
   /**
    * @return the pointer depth. Example for C++: "char*" has pointer-depth 1, "char***" has pointer-depth 3
    */
   int pointerDepth() const;
   /**
    * Sets the pointer-depth to the specified count.
    *
    * When the pointer-depth is increased, the "isConstPointer" values for new depths will be initialized with false.
    *
    * For efficiency-reasons the maximum currently is 23.
    */
   void setPointerDepth(int);
 
   /**
    * Whether the target of pointer 'depthNumber' is constant
    */
   bool isConstPointer(int depthNumber) const;
   void setIsConstPointer(int depthNumber, bool constant);
 
   QString toString(IdentifierStringFormattingOptions options = NoOptions) const;
 
   uint hash() const;
 
   /**
    * The comparison-operators do not respect explicitlyGlobal and isExpression, they only respect the real scope.
    * This is for convenient use in hash-tables etc.
    */
   bool operator==(const IndexedTypeIdentifier& rhs) const;
   bool operator!=(const IndexedTypeIdentifier& rhs) const;
 
 private:
   IndexedQualifiedIdentifier m_identifier;
   // The overall number of bits shared by these bit-fields should not exceed 32,
   // so that we don't waste space. IndexedTypeIdentifer should be as compact as possible.
   bool m_isConstant : 1;
   bool m_isReference : 1;
   bool m_isRValue : 1;
   bool m_isVolatile : 1;
   uint m_pointerDepth : 5;
   uint m_pointerConstMask : 23;
 };
 
 KDEVPLATFORMLANGUAGE_EXPORT uint qHash(const IndexedTypeIdentifier& id);
 KDEVPLATFORMLANGUAGE_EXPORT uint qHash(const QualifiedIdentifier& id);
 KDEVPLATFORMLANGUAGE_EXPORT uint qHash(const Identifier& id);
 
 inline uint qHash(const IndexedIdentifier& id)
 {
-  return id.getIndex();
+  return id.index();
 }
 
 inline uint qHash(const IndexedQualifiedIdentifier& id)
 {
-  return id.getIndex();
+  return id.index();
 }
 
 }
 
 Q_DECLARE_TYPEINFO(KDevelop::IndexedTypeIdentifier, Q_MOVABLE_TYPE);
 Q_DECLARE_TYPEINFO(KDevelop::IndexedQualifiedIdentifier, Q_MOVABLE_TYPE);
 Q_DECLARE_TYPEINFO(KDevelop::IndexedIdentifier, Q_MOVABLE_TYPE);
 Q_DECLARE_METATYPE(KDevelop::IndexedQualifiedIdentifier)
 Q_DECLARE_METATYPE(KDevelop::IndexedIdentifier)
 
 Q_DECLARE_TYPEINFO(KDevelop::QualifiedIdentifier, Q_MOVABLE_TYPE);
 Q_DECLARE_TYPEINFO(KDevelop::Identifier, Q_MOVABLE_TYPE);
 Q_DECLARE_METATYPE(KDevelop::QualifiedIdentifier)
 Q_DECLARE_METATYPE(KDevelop::Identifier)
 
 /**
  * {q,k}Debug() stream operator: Writes the Identifier to the debug output.
  */
 KDEVPLATFORMLANGUAGE_EXPORT QDebug operator<<(QDebug s, const KDevelop::Identifier& identifier);
 
 /**
  * {q,k}Debug() stream operator: Writes the QualifiedIdentifier to the debug output.
  */
 KDEVPLATFORMLANGUAGE_EXPORT QDebug operator<<(QDebug s, const KDevelop::QualifiedIdentifier& identifier);
 
 #endif // KDEVPLATFORM_IDENTIFIER_H
diff --git a/kdevplatform/language/duchain/indexeddeclaration.cpp b/kdevplatform/language/duchain/indexeddeclaration.cpp
index a07f071015..1f989e22b2 100644
--- a/kdevplatform/language/duchain/indexeddeclaration.cpp
+++ b/kdevplatform/language/duchain/indexeddeclaration.cpp
@@ -1,57 +1,57 @@
 /* This file is part of KDevelop
     Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "indexeddeclaration.h"
 
 #include "declaration.h"
 #include "duchain.h"
 #include "topducontextdynamicdata.h"
 
 using namespace KDevelop;
 
 IndexedDeclaration::IndexedDeclaration(uint topContext, uint declarationIndex)
   : m_topContext(topContext)
   , m_declarationIndex(declarationIndex)
 {
 }
 
 IndexedDeclaration::IndexedDeclaration(const Declaration* decl)
 {
   if(decl) {
     m_topContext = decl->topContext()->ownIndex();
     m_declarationIndex = decl->m_indexInTopContext;
   }else{
     m_topContext = 0;
     m_declarationIndex = 0;
   }
 }
 
 Declaration* IndexedDeclaration::declaration() const
 {
   if(isDummy())
     return nullptr;
 //   ENSURE_CHAIN_READ_LOCKED
   if(!m_topContext || !m_declarationIndex)
     return nullptr;
 
   TopDUContext* ctx = DUChain::self()->chainForIndex(m_topContext);
   if(!ctx)
     return nullptr;
 
-  return ctx->m_dynamicData->getDeclarationForIndex(m_declarationIndex);
+  return ctx->m_dynamicData->declarationForIndex(m_declarationIndex);
 }
diff --git a/kdevplatform/language/duchain/indexedducontext.cpp b/kdevplatform/language/duchain/indexedducontext.cpp
index a1581c35cb..249ce609f5 100644
--- a/kdevplatform/language/duchain/indexedducontext.cpp
+++ b/kdevplatform/language/duchain/indexedducontext.cpp
@@ -1,72 +1,72 @@
 /* This file is part of KDevelop
     Copyright 2006 Hamish Rodda <rodda@kde.org>
     Copyright 2007-2009 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 "indexedducontext.h"
 
 #include "ducontext.h"
 #include "ducontextdata.h"
 #include "ducontextdynamicdata.h"
 #include "topducontext.h"
 #include "duchain.h"
 #include "topducontextdynamicdata.h"
 
 using namespace KDevelop;
 
 IndexedDUContext::IndexedDUContext(uint topContext, uint contextIndex)
   : m_topContext(topContext)
   , m_contextIndex(contextIndex)
 {
 }
 
 IndexedDUContext::IndexedDUContext(DUContext* ctx)
 {
   if(ctx) {
     m_topContext = ctx->topContext()->ownIndex();
     m_contextIndex = ctx->m_dynamicData->m_indexInTopContext;
   }else{
     m_topContext = 0;
     m_contextIndex = 0;
   }
 }
 
 IndexedTopDUContext IndexedDUContext::indexedTopContext() const
 {
   if(isDummy()) {
     return IndexedTopDUContext();
   }
   return IndexedTopDUContext(m_topContext);
 }
 
 DUContext* IndexedDUContext::context() const
 {
   if(isDummy())
     return nullptr;
 //   ENSURE_CHAIN_READ_LOCKED
   if(!m_topContext)
     return nullptr;
 
   TopDUContext* ctx = DUChain::self()->chainForIndex(m_topContext);
   if(!ctx)
     return nullptr;
 
   if(!m_contextIndex)
     return ctx;
 
-  return ctx->m_dynamicData->getContextForIndex(m_contextIndex);
+  return ctx->m_dynamicData->contextForIndex(m_contextIndex);
 }
diff --git a/kdevplatform/language/duchain/localindexeddeclaration.cpp b/kdevplatform/language/duchain/localindexeddeclaration.cpp
index 7cbd30924b..d4b4e38a6b 100644
--- a/kdevplatform/language/duchain/localindexeddeclaration.cpp
+++ b/kdevplatform/language/duchain/localindexeddeclaration.cpp
@@ -1,52 +1,52 @@
 /* This file is part of KDevelop
     Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "localindexeddeclaration.h"
 
 #include "declaration.h"
 #include "topducontextdynamicdata.h"
 #include "topducontext.h"
 
 using namespace KDevelop;
 
 LocalIndexedDeclaration::LocalIndexedDeclaration(Declaration* decl)
   : m_declarationIndex(decl ? decl->m_indexInTopContext : 0)
 {
 }
 
 LocalIndexedDeclaration::LocalIndexedDeclaration(uint declarationIndex)
   : m_declarationIndex(declarationIndex)
 {
 }
 
 Declaration* LocalIndexedDeclaration::data(TopDUContext* top) const
 {
   if(!m_declarationIndex)
     return nullptr;
   Q_ASSERT(top);
-  return top->m_dynamicData->getDeclarationForIndex(m_declarationIndex);
+  return top->m_dynamicData->declarationForIndex(m_declarationIndex);
 }
 
 bool LocalIndexedDeclaration::isLoaded(TopDUContext* top) const
 {
   if(!m_declarationIndex)
     return false;
 
   Q_ASSERT(top);
   return top->m_dynamicData->isDeclarationForIndexLoaded(m_declarationIndex);
 }
diff --git a/kdevplatform/language/duchain/localindexedducontext.cpp b/kdevplatform/language/duchain/localindexedducontext.cpp
index 75b8e8e22e..9db7d910c8 100644
--- a/kdevplatform/language/duchain/localindexedducontext.cpp
+++ b/kdevplatform/language/duchain/localindexedducontext.cpp
@@ -1,58 +1,58 @@
 /* This file is part of KDevelop
     Copyright 2006 Hamish Rodda <rodda@kde.org>
     Copyright 2007-2009 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 "localindexedducontext.h"
 
 #include "ducontextdata.h"
 #include "ducontext.h"
 #include "topducontextdynamicdata.h"
 #include "ducontextdynamicdata.h"
 #include "topducontext.h"
 
 using namespace KDevelop;
 
 LocalIndexedDUContext::LocalIndexedDUContext(uint contextIndex)
   : m_contextIndex(contextIndex)
 {
 }
 
 LocalIndexedDUContext::LocalIndexedDUContext(DUContext* ctx)
 {
   if(ctx) {
     m_contextIndex = ctx->m_dynamicData->m_indexInTopContext;
   }else{
     m_contextIndex = 0;
   }
 }
 
 bool LocalIndexedDUContext::isLoaded(TopDUContext* top) const
 {
   if(!m_contextIndex)
     return false;
   else
     return top->m_dynamicData->isContextForIndexLoaded(m_contextIndex);
 }
 
 DUContext* LocalIndexedDUContext::data(TopDUContext* top) const
 {
   if(!m_contextIndex)
     return nullptr;
   else
-    return top->m_dynamicData->getContextForIndex(m_contextIndex);
+    return top->m_dynamicData->contextForIndex(m_contextIndex);
 }
diff --git a/kdevplatform/language/duchain/navigation/abstractdeclarationnavigationcontext.cpp b/kdevplatform/language/duchain/navigation/abstractdeclarationnavigationcontext.cpp
index b76b616a9e..70d66942b8 100644
--- a/kdevplatform/language/duchain/navigation/abstractdeclarationnavigationcontext.cpp
+++ b/kdevplatform/language/duchain/navigation/abstractdeclarationnavigationcontext.cpp
@@ -1,822 +1,822 @@
 /*
    Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "abstractdeclarationnavigationcontext.h"
 
 #include <QTextDocument>
 
 #include <KLocalizedString>
 
 #include "../functiondeclaration.h"
 #include "../functiondefinition.h"
 #include "../classfunctiondeclaration.h"
 #include "../namespacealiasdeclaration.h"
 #include "../forwarddeclaration.h"
 #include "../types/enumeratortype.h"
 #include "../types/enumerationtype.h"
 #include "../types/functiontype.h"
 #include "../duchainutils.h"
 #include "../types/pointertype.h"
 #include "../types/referencetype.h"
 #include "../types/typeutils.h"
 #include "../types/typesystem.h"
 #include "../persistentsymboltable.h"
 #include <debug.h>
 #include <interfaces/icore.h>
 #include <interfaces/idocumentationcontroller.h>
 #include <duchain/types/typealiastype.h>
 #include <duchain/types/structuretype.h>
 #include <duchain/classdeclaration.h>
 
 namespace KDevelop {
 
 class AbstractDeclarationNavigationContextPrivate
 {
 public:
   DeclarationPointer m_declaration;
   bool m_fullBackwardSearch = false;
 };
 
 AbstractDeclarationNavigationContext::AbstractDeclarationNavigationContext(const DeclarationPointer& decl,
                                                                            const TopDUContextPointer& topContext,
                                                                            AbstractNavigationContext* previousContext)
   : AbstractNavigationContext((topContext ? topContext : TopDUContextPointer(decl ? decl->topContext() : nullptr)), previousContext)
   , d(new AbstractDeclarationNavigationContextPrivate)
 {
   d->m_declaration = decl;
 
   //Jump from definition to declaration if possible
   FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(d->m_declaration.data());
   if(definition && definition->declaration())
     d->m_declaration = DeclarationPointer(definition->declaration());
 }
 
 AbstractDeclarationNavigationContext::~AbstractDeclarationNavigationContext()
 {
 }
 
 QString AbstractDeclarationNavigationContext::name() const
 {
   if(d->m_declaration.data())
     return prettyQualifiedIdentifier(d->m_declaration).toString();
   else
     return declarationName(d->m_declaration);
 }
 
 QString AbstractDeclarationNavigationContext::html(bool shorten)
 {
   DUChainReadLocker lock(DUChain::lock(), 300);
   if ( !lock.locked() ) {
     return {};
   }
 
   clear();
   AbstractNavigationContext::html(shorten);
 
   modifyHtml()  += QLatin1String("<html><body><p>") + fontSizePrefix(shorten);
 
   addExternalHtml(prefix());
 
   if(!d->m_declaration.data()) {
     modifyHtml() += i18n("<br /> lost declaration <br />");
     return currentHtml();
   }
 
   if(auto context = previousContext()) {
     const QString link = createLink(context->name(), context->name(),
                                     NavigationAction(context));
     modifyHtml() += navigationHighlight(i18n("Back to %1<br />", link));
   }
 
   QExplicitlySharedDataPointer<IDocumentation> doc;
 
   if( !shorten ) {
     doc = ICore::self()->documentationController()->documentationForDeclaration(d->m_declaration.data());
 
     const AbstractFunctionDeclaration* function = dynamic_cast<const AbstractFunctionDeclaration*>(d->m_declaration.data());
     if( function ) {
       htmlFunction();
     } else if( d->m_declaration->isTypeAlias() || d->m_declaration->type<EnumeratorType>() || d->m_declaration->kind() == Declaration::Instance ) {
       if( d->m_declaration->isTypeAlias() )
         modifyHtml() += importantHighlight(QStringLiteral("typedef "));
 
       if(d->m_declaration->type<EnumeratorType>())
         modifyHtml() += i18n("enumerator ");
 
       AbstractType::Ptr useType = d->m_declaration->abstractType();
       if(d->m_declaration->isTypeAlias()) {
         //Do not show the own name as type of typedefs
         if(useType.cast<TypeAliasType>())
           useType = useType.cast<TypeAliasType>()->type();
       }
 
       eventuallyMakeTypeLinks( useType );
 
       modifyHtml() += QLatin1Char(' ') + identifierHighlight(declarationName(d->m_declaration).toHtmlEscaped(), d->m_declaration);
 
       if(auto integralType = d->m_declaration->type<ConstantIntegralType>()) {
         const QString plainValue = integralType->valueAsString();
         if (!plainValue.isEmpty()) {
           modifyHtml() += QStringLiteral(" = ") + plainValue;
         }
       }
 
       modifyHtml() += QStringLiteral("<br>");
     }else{
       if( d->m_declaration->kind() == Declaration::Type && d->m_declaration->abstractType().cast<StructureType>() ) {
         htmlClass();
       }
       if ( d->m_declaration->kind() == Declaration::Namespace ) {
         modifyHtml() += i18n("namespace %1 ", identifierHighlight(d->m_declaration->qualifiedIdentifier().toString().toHtmlEscaped(), d->m_declaration));
       } else if ( d->m_declaration->kind() == Declaration::NamespaceAlias ) {
         modifyHtml() += identifierHighlight(declarationName(d->m_declaration).toHtmlEscaped(), d->m_declaration);
       }
 
       if(d->m_declaration->type<EnumerationType>()) {
         EnumerationType::Ptr enumeration = d->m_declaration->type<EnumerationType>();
         modifyHtml() += i18n("enumeration %1 ", identifierHighlight(d->m_declaration->identifier().toString().toHtmlEscaped(), d->m_declaration));
       }
 
       if(d->m_declaration->isForwardDeclaration()) {
         ForwardDeclaration* forwardDec = static_cast<ForwardDeclaration*>(d->m_declaration.data());
         Declaration* resolved = forwardDec->resolve(topContext().data());
         if(resolved) {
           modifyHtml() += i18n("(resolved forward-declaration: ");
           makeLink(resolved->identifier().toString(), DeclarationPointer(resolved), NavigationAction::NavigateDeclaration );
           modifyHtml() += i18n(") ");
         }else{
           modifyHtml() += i18n("(unresolved forward-declaration) ");
           QualifiedIdentifier id = forwardDec->qualifiedIdentifier();
           const auto& forwardDecFile = forwardDec->topContext()->parsingEnvironmentFile();
           uint count;
           const IndexedDeclaration* decls;
           PersistentSymbolTable::self().declarations(id, count, decls);
           for(uint a = 0; a < count; ++a) {
             auto dec = decls[a].data();
             if (!dec || dec->isForwardDeclaration()) {
                 continue;
             }
             const auto& decFile = forwardDec->topContext()->parsingEnvironmentFile();
             if ((static_cast<bool>(decFile) != static_cast<bool>(forwardDecFile)) ||
                 (decFile && forwardDecFile && decFile->language() != forwardDecFile->language()))
             {
                 // the language of the declarations must match
                 continue;
             }
             modifyHtml() += QStringLiteral("<br />");
             makeLink(i18n("possible resolution from"), DeclarationPointer(dec), NavigationAction::NavigateDeclaration);
             modifyHtml() += QLatin1Char(' ') + dec->url().str();
           }
         }
       }
       modifyHtml() += QStringLiteral("<br />");
     }
   }else{
     AbstractType::Ptr showType = d->m_declaration->abstractType();
     if(showType && showType.cast<FunctionType>()) {
       showType = showType.cast<FunctionType>()->returnType();
       if(showType)
         modifyHtml() += labelHighlight(i18n("Returns: "));
     }else  if(showType) {
       modifyHtml() += labelHighlight(i18n("Type: "));
     }
 
     if(showType) {
       eventuallyMakeTypeLinks(showType);
       modifyHtml() += QStringLiteral(" ");
     }
   }
 
   QualifiedIdentifier identifier = d->m_declaration->qualifiedIdentifier();
   if( identifier.count() > 1 ) {
     if( d->m_declaration->context() && d->m_declaration->context()->owner() )
     {
       Declaration* decl = d->m_declaration->context()->owner();
 
       FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(decl);
       if(definition && definition->declaration())
         decl = definition->declaration();
 
       if(decl->abstractType().cast<EnumerationType>())
         modifyHtml() += labelHighlight(i18n("Enum: "));
       else
         modifyHtml() += labelHighlight(i18n("Container: "));
 
       makeLink( declarationName(DeclarationPointer(decl)), DeclarationPointer(decl), NavigationAction::NavigateDeclaration );
       modifyHtml() += QStringLiteral(" ");
     } else {
       QualifiedIdentifier parent = identifier;
       parent.pop();
       modifyHtml() += labelHighlight(i18n("Scope: %1 ", typeHighlight(parent.toString().toHtmlEscaped())));
     }
   }
 
   if( shorten && !d->m_declaration->comment().isEmpty() ) {
     QString comment = QString::fromUtf8(d->m_declaration->comment());
     if( comment.length() > 60 ) {
       comment.truncate(60);
       comment += QLatin1String("...");
     }
     comment.replace(QLatin1Char('\n'), QLatin1Char(' '));
     comment.replace(QLatin1String("<br />"), QLatin1String(" "));
     comment.replace(QLatin1String("<br/>"), QLatin1String(" "));
     modifyHtml() += commentHighlight(comment.toHtmlEscaped()) + QLatin1String("   ");
   }
 
 
   QString access = stringFromAccess(d->m_declaration);
   if( !access.isEmpty() )
     modifyHtml() += labelHighlight(i18n("Access: %1 ", propertyHighlight(access.toHtmlEscaped())));
 
 
   ///@todo Enumerations
 
   QString detailsHtml;
   const QStringList details = declarationDetails(d->m_declaration);
   if( !details.isEmpty() ) {
     bool first = true;
     for (const QString& str : details) {
       if( !first )
         detailsHtml += QLatin1String(", ");
       first = false;
       detailsHtml += propertyHighlight(str);
     }
   }
 
   QString kind = declarationKind(d->m_declaration);
   if( !kind.isEmpty() ) {
     if( !detailsHtml.isEmpty() )
       modifyHtml() += labelHighlight(i18n("Kind: %1 %2 ", importantHighlight(kind.toHtmlEscaped()), detailsHtml));
     else
       modifyHtml() += labelHighlight(i18n("Kind: %1 ", importantHighlight(kind.toHtmlEscaped())));
   }
 
   if (d->m_declaration->isDeprecated()) {
     modifyHtml() += labelHighlight(i18n("Status: %1 ", propertyHighlight(i18n("Deprecated"))));
   }
 
   modifyHtml() += QStringLiteral("<br />");
 
   if(!shorten)
     htmlAdditionalNavigation();
 
   if( !shorten ) {
     if(dynamic_cast<FunctionDefinition*>(d->m_declaration.data()))
       modifyHtml() += labelHighlight(i18n( "Def.: " ));
     else
       modifyHtml() += labelHighlight(i18n( "Decl.: " ));
 
     makeLink( QStringLiteral("%1 :%2").arg( d->m_declaration->url().toUrl().fileName() ).arg( d->m_declaration->rangeInCurrentRevision().start().line()+1 ), d->m_declaration, NavigationAction::JumpToSource );
     modifyHtml() += QStringLiteral(" ");
     //modifyHtml() += "<br />";
     if(!dynamic_cast<FunctionDefinition*>(d->m_declaration.data())) {
       if( FunctionDefinition* definition = FunctionDefinition::definition(d->m_declaration.data()) ) {
         modifyHtml() += labelHighlight(i18n( " Def.: " ));
         makeLink( QStringLiteral("%1 :%2").arg( definition->url().toUrl().fileName() ).arg( definition->rangeInCurrentRevision().start().line()+1 ), DeclarationPointer(definition), NavigationAction::JumpToSource );
       }
     }
 
     if( FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(d->m_declaration.data()) ) {
       if(definition->declaration()) {
         modifyHtml() += labelHighlight(i18n( " Decl.: " ));
         makeLink( QStringLiteral("%1 :%2").arg( definition->declaration()->url().toUrl().fileName() ).arg( definition->declaration()->rangeInCurrentRevision().start().line()+1 ), DeclarationPointer(definition->declaration()), NavigationAction::JumpToSource );
       }
     }
 
     modifyHtml() += QStringLiteral(" "); //The action name _must_ stay "show_uses", since that is also used from outside
     makeLink(i18n("Show uses"), QStringLiteral("show_uses"), NavigationAction(d->m_declaration, NavigationAction::NavigateUses));
   }
 
   QByteArray declarationComment = d->m_declaration->comment();
   if( !shorten && (!declarationComment.isEmpty() || doc) ) {
     modifyHtml() += QStringLiteral("<p>");
 
     if(doc) {
       QString comment = doc->description();
       connect(doc.data(), &IDocumentation::descriptionChanged, this, &AbstractDeclarationNavigationContext::contentsChanged);
 
       if(!comment.isEmpty()) {
         modifyHtml() += QLatin1String("<p>") + commentHighlight(comment) + QLatin1String("</p>");
       }
     }
 
     QString comment = QString::fromUtf8(declarationComment);
     if(!comment.isEmpty()) {
       // if the first paragraph does not contain a tag, we assume that this is a plain-text comment
       if (!Qt::mightBeRichText(comment)) {
         // still might contain extra html tags for line breaks (this is the case for doxygen-style comments sometimes)
         // let's protect them from being removed completely
         comment.replace(QRegExp(QStringLiteral("<br */>")), QStringLiteral("\n"));
         comment = comment.toHtmlEscaped();
         comment.replace(QLatin1Char('\n'), QLatin1String("<br />")); //Replicate newlines in html
       }
       modifyHtml() += commentHighlight(comment);
       modifyHtml() += QStringLiteral("</p>");
     }
   }
 
   if(!shorten) {
     modifyHtml() += declarationSizeInformation(d->m_declaration);
   }
 
     if(!shorten && doc) {
       modifyHtml() += QLatin1String("<p>") + i18n("Show documentation for ");
       makeLink(prettyQualifiedName(d->m_declaration),
                d->m_declaration, NavigationAction::ShowDocumentation);
       modifyHtml() += QStringLiteral("</p>");
     }
 
 
     //modifyHtml() += "<br />";
 
   addExternalHtml(suffix());
 
   modifyHtml() += fontSizeSuffix(shorten) + QLatin1String("</p></body></html>");
 
   return currentHtml();
 }
 
 AbstractType::Ptr AbstractDeclarationNavigationContext::typeToShow(AbstractType::Ptr type) {
   return type;
 }
 
 void AbstractDeclarationNavigationContext::htmlFunction()
 {
   const AbstractFunctionDeclaration* function = dynamic_cast<const AbstractFunctionDeclaration*>(d->m_declaration.data());
   Q_ASSERT(function);
 
   const ClassFunctionDeclaration* classFunDecl = dynamic_cast<const ClassFunctionDeclaration*>(d->m_declaration.data());
   const FunctionType::Ptr type = d->m_declaration->abstractType().cast<FunctionType>();
   if( !type ) {
     modifyHtml() += errorHighlight(QStringLiteral("Invalid type<br />"));
     return;
   }
 
   if( !classFunDecl || (!classFunDecl->isConstructor() && !classFunDecl->isDestructor()) ) {
     // only print return type for global functions and non-ctor/dtor methods
     eventuallyMakeTypeLinks( type->returnType() );
   }
 
   modifyHtml() += QLatin1Char(' ') + identifierHighlight(prettyIdentifier(d->m_declaration).toString().toHtmlEscaped(), d->m_declaration);
 
   if( type->indexedArgumentsSize() == 0 )
   {
     modifyHtml() += QStringLiteral("()");
   } else {
     modifyHtml() += QStringLiteral("( ");
 
     bool first = true;
     int firstDefaultParam = type->indexedArgumentsSize() - function->defaultParametersSize();
     int currentArgNum = 0;
 
     QVector<Declaration*> decls;
-    if (DUContext* argumentContext = DUChainUtils::getArgumentContext(d->m_declaration.data())) {
+    if (DUContext* argumentContext = DUChainUtils::argumentContext(d->m_declaration.data())) {
       decls = argumentContext->localDeclarations(topContext().data());
     }
     foreach(const AbstractType::Ptr& argType, type->arguments()) {
       if( !first )
         modifyHtml() += QStringLiteral(", ");
       first = false;
 
       eventuallyMakeTypeLinks( argType );
       if (currentArgNum < decls.size()) {
         modifyHtml() += QLatin1Char(' ') + identifierHighlight(decls[currentArgNum]->identifier().toString().toHtmlEscaped(), d->m_declaration);
       }
 
       if (currentArgNum >= firstDefaultParam) {
         IndexedString defaultStr = function->defaultParameters()[currentArgNum - firstDefaultParam];
         if (!defaultStr.isEmpty()) {
           modifyHtml() += QLatin1String(" = ") + defaultStr.str().toHtmlEscaped();
         }
       }
 
       ++currentArgNum;
     }
 
     modifyHtml() += QStringLiteral(" )");
   }
   modifyHtml() += QStringLiteral("<br />");
 }
 
 
 Identifier AbstractDeclarationNavigationContext::prettyIdentifier(const DeclarationPointer& decl) const
 {
   Identifier ret;
   QualifiedIdentifier q = prettyQualifiedIdentifier(decl);
   if(!q.isEmpty())
     ret = q.last();
 
   return ret;
 }
 
 QualifiedIdentifier AbstractDeclarationNavigationContext::prettyQualifiedIdentifier(const DeclarationPointer& decl) const
 {
   if(decl)
     return decl->qualifiedIdentifier();
   else
     return QualifiedIdentifier();
 }
 
 
 QString AbstractDeclarationNavigationContext::prettyQualifiedName(const DeclarationPointer& decl) const
 {
   const auto qid = prettyQualifiedIdentifier(decl);
   if (qid.isEmpty()) {
     return i18nc("An anonymous declaration (class, function, etc.)", "<anonymous>");
   }
 
   return qid.toString();
 }
 
 void AbstractDeclarationNavigationContext::htmlAdditionalNavigation()
 {
   ///Check if the function overrides or hides another one
   const ClassFunctionDeclaration* classFunDecl = dynamic_cast<const ClassFunctionDeclaration*>(d->m_declaration.data());
   if(classFunDecl) {
 
-    Declaration* overridden = DUChainUtils::getOverridden(d->m_declaration.data());
+    Declaration* overridden = DUChainUtils::overridden(d->m_declaration.data());
 
     if(overridden) {
         modifyHtml() += i18n("Overrides a ");
         makeLink(i18n("function"), QStringLiteral("jump_to_overridden"), NavigationAction(DeclarationPointer(overridden), NavigationAction::NavigateDeclaration));
         modifyHtml() += i18n(" from ");
         makeLink(prettyQualifiedName(DeclarationPointer(overridden->context()->owner())),
                  QStringLiteral("jump_to_overridden_container"),
                  NavigationAction(DeclarationPointer(overridden->context()->owner()),
                                   NavigationAction::NavigateDeclaration));
 
         modifyHtml() += QStringLiteral("<br />");
     }else{
       //Check if this declarations hides other declarations
       QList<Declaration*> decls;
       foreach(const DUContext::Import &import, d->m_declaration->context()->importedParentContexts())
         if(import.context(topContext().data()))
           decls += import.context(topContext().data())->findDeclarations(QualifiedIdentifier(d->m_declaration->identifier()),
                                                 CursorInRevision::invalid(), AbstractType::Ptr(), topContext().data(), DUContext::DontSearchInParent);
       uint num = 0;
       foreach(Declaration* decl, decls) {
         modifyHtml() += i18n("Hides a ");
         makeLink(i18n("function"), QStringLiteral("jump_to_hide_%1").arg(num),
                  NavigationAction(DeclarationPointer(decl),
                                   NavigationAction::NavigateDeclaration));
         modifyHtml() += i18n(" from ");
         makeLink(prettyQualifiedName(DeclarationPointer(decl->context()->owner())),
                  QStringLiteral("jump_to_hide_container_%1").arg(num),
                  NavigationAction(DeclarationPointer(decl->context()->owner()),
                                   NavigationAction::NavigateDeclaration));
 
         modifyHtml() += QStringLiteral("<br />");
         ++num;
       }
     }
 
     ///Show all places where this function is overridden
     if(classFunDecl->isVirtual()) {
       Declaration* classDecl = d->m_declaration->context()->owner();
       if(classDecl) {
         uint maxAllowedSteps = d->m_fullBackwardSearch ? (uint)-1 : 10;
-        const QList<Declaration*> overriders = DUChainUtils::getOverriders(classDecl, classFunDecl, maxAllowedSteps);
+        const QList<Declaration*> overriders = DUChainUtils::overriders(classDecl, classFunDecl, maxAllowedSteps);
 
         if(!overriders.isEmpty()) {
           modifyHtml() += i18n("Overridden in ");
           bool first = true;
           for (Declaration* overrider : overriders) {
             if(!first)
               modifyHtml() += QStringLiteral(", ");
             first = false;
 
             const auto owner = DeclarationPointer(overrider->context()->owner());
             const QString name = prettyQualifiedName(owner);
             makeLink(name, name, NavigationAction(DeclarationPointer(overrider), NavigationAction::NavigateDeclaration));
           }
           modifyHtml() += QStringLiteral("<br />");
         }
         if(maxAllowedSteps == 0)
           createFullBackwardSearchLink(overriders.isEmpty() ? i18n("Overriders possible, show all") : i18n("More overriders possible, show all"));
       }
     }
   }
 
   ///Show all classes that inherit this one
   uint maxAllowedSteps = d->m_fullBackwardSearch ? (uint)-1 : 10;
-  const QList<Declaration*> inheriters = DUChainUtils::getInheriters(d->m_declaration.data(), maxAllowedSteps);
+  const QList<Declaration*> inheriters = DUChainUtils::inheriters(d->m_declaration.data(), maxAllowedSteps);
 
   if(!inheriters.isEmpty()) {
       modifyHtml() += i18n("Inherited by ");
       bool first = true;
       for (Declaration* importer : inheriters) {
         if(!first)
           modifyHtml() += QStringLiteral(", ");
         first = false;
 
         const QString importerName = prettyQualifiedName(DeclarationPointer(importer));
         makeLink(importerName, importerName,
                  NavigationAction(DeclarationPointer(importer), NavigationAction::NavigateDeclaration));
       }
       modifyHtml() += QStringLiteral("<br />");
   }
   if(maxAllowedSteps == 0)
     createFullBackwardSearchLink(inheriters.isEmpty() ? i18n("Inheriters possible, show all") : i18n("More inheriters possible, show all"));
 }
 
 void AbstractDeclarationNavigationContext::createFullBackwardSearchLink(const QString& string)
 {
   makeLink(string, QStringLiteral("m_fullBackwardSearch=true"), NavigationAction(QStringLiteral("m_fullBackwardSearch=true")));
   modifyHtml() += QStringLiteral("<br />");
 }
 
 NavigationContextPointer AbstractDeclarationNavigationContext::executeKeyAction(const QString& key)
 {
   if(key == QLatin1String("m_fullBackwardSearch=true")) {
     d->m_fullBackwardSearch = true;
     clear();
   }
   return NavigationContextPointer(this);
 }
 
 void AbstractDeclarationNavigationContext::htmlClass()
 {
   StructureType::Ptr klass = d->m_declaration->abstractType().cast<StructureType>();
   Q_ASSERT(klass);
 
   ClassDeclaration* classDecl = dynamic_cast<ClassDeclaration*>(klass->declaration(topContext().data()));
   if(classDecl) {
     switch ( classDecl->classType() ) {
       case ClassDeclarationData::Class:
         modifyHtml() += QStringLiteral("class ");
         break;
       case ClassDeclarationData::Struct:
         modifyHtml() += QStringLiteral("struct ");
         break;
       case ClassDeclarationData::Union:
         modifyHtml() += QStringLiteral("union ");
         break;
       case ClassDeclarationData::Interface:
         modifyHtml() += QStringLiteral("interface ");
         break;
       case ClassDeclarationData::Trait:
         modifyHtml() += QStringLiteral("trait ");
         break;
     }
     eventuallyMakeTypeLinks( klass.cast<AbstractType>() );
 
     FOREACH_FUNCTION( const BaseClassInstance& base, classDecl->baseClasses ) {
       modifyHtml() += QLatin1String(", ") + stringFromAccess(base.access) + QLatin1Char(' ') + (base.virtualInheritance ? QStringLiteral("virtual") : QString()) + QLatin1Char(' ');
       eventuallyMakeTypeLinks(base.baseClass.abstractType());
     }
   } else {
     /// @todo How can we get here? and should this really be a class?
     modifyHtml() += QStringLiteral("class ");
     eventuallyMakeTypeLinks( klass.cast<AbstractType>() );
   }
   modifyHtml() += QStringLiteral(" ");
 }
 
 void AbstractDeclarationNavigationContext::htmlIdentifiedType(AbstractType::Ptr type, const IdentifiedType* idType)
 {
   Q_ASSERT(type);
   Q_ASSERT(idType);
 
   if( Declaration* decl = idType->declaration(topContext().data()) ) {
 
     //Remove the last template-identifiers, because we create those directly
     QualifiedIdentifier id = prettyQualifiedIdentifier(DeclarationPointer(decl));
     Identifier lastId = id.last();
     id.pop();
     lastId.clearTemplateIdentifiers();
     id.push(lastId);
 
     if(decl->context() && decl->context()->owner()) {
 
       //Also create full type-links for the context around
       AbstractType::Ptr contextType = decl->context()->owner()->abstractType();
       IdentifiedType* contextIdType = dynamic_cast<IdentifiedType*>(contextType.data());
       if(contextIdType && !contextIdType->equals(idType)) {
         //Create full type information for the context
         if(!id.isEmpty())
           id = id.mid(id.count()-1);
         htmlIdentifiedType(contextType, contextIdType);
         modifyHtml() += QStringLiteral("::").toHtmlEscaped();
       }
     }
 
     //We leave out the * and & reference and pointer signs, those are added to the end
     makeLink(id.toString() , DeclarationPointer(idType->declaration(topContext().data())), NavigationAction::NavigateDeclaration );
   } else {
     qCDebug(LANGUAGE) << "could not resolve declaration:" << idType->declarationId().isDirect() << idType->qualifiedIdentifier().toString() << "in top-context" << topContext()->url().str();
     modifyHtml() += typeHighlight(type->toString().toHtmlEscaped());
   }
 }
 
 void AbstractDeclarationNavigationContext::eventuallyMakeTypeLinks( AbstractType::Ptr type )
 {
   type = typeToShow(type);
 
   if( !type ) {
     modifyHtml() += typeHighlight(QStringLiteral("<no type>").toHtmlEscaped());
     return;
   }
 
   AbstractType::Ptr target = TypeUtils::targetTypeKeepAliases( type, topContext().data() );
   const IdentifiedType* idType = dynamic_cast<const IdentifiedType*>( target.data() );
 
   qCDebug(LANGUAGE) << "making type-links for" << type->toString();
 
   if( idType && idType->declaration(topContext().data()) ) {
     ///@todo This is C++ specific, move into subclass
 
     if(target->modifiers() & AbstractType::ConstModifier)
       modifyHtml() += typeHighlight(QStringLiteral("const "));
 
     htmlIdentifiedType(target, idType);
 
     //We need to exchange the target type, else template-parameters may confuse this
     SimpleTypeExchanger exchangeTarget(target, AbstractType::Ptr());
 
     AbstractType::Ptr exchanged = exchangeTarget.exchange(type);
 
     if(exchanged) {
       QString typeSuffixString = exchanged->toString();
       QRegExp suffixExp(QStringLiteral("\\&|\\*"));
       int suffixPos = typeSuffixString.indexOf(suffixExp);
       if(suffixPos != -1)
         modifyHtml() += typeHighlight(typeSuffixString.mid(suffixPos));
     }
 
   } else {
     if(idType) {
       qCDebug(LANGUAGE) << "identified type could not be resolved:" << idType->qualifiedIdentifier() << idType->declarationId().isValid() << idType->declarationId().isDirect();
     }
     modifyHtml() += typeHighlight(type->toString().toHtmlEscaped());
   }
 }
 
 DeclarationPointer AbstractDeclarationNavigationContext::declaration() const
 {
   return d->m_declaration;
 }
 
 QString AbstractDeclarationNavigationContext::identifierHighlight(const QString& identifier, const DeclarationPointer& decl) const
 {
   QString ret = nameHighlight(identifier);
   if (!decl) {
     return ret;
   }
 
   if (decl->isDeprecated()) {
     ret = QStringLiteral("<i>") + ret + QStringLiteral("</i>");
   }
   return ret;
 }
 
 QString AbstractDeclarationNavigationContext::stringFromAccess(Declaration::AccessPolicy access)
 {
   switch(access) {
     case Declaration::Private:
       return QStringLiteral("private");
     case Declaration::Protected:
       return QStringLiteral("protected");
     case Declaration::Public:
       return QStringLiteral("public");
     default:
       break;
   }
   return QString();
 }
 
 QString AbstractDeclarationNavigationContext::stringFromAccess(const DeclarationPointer& decl)
 {
   const ClassMemberDeclaration* memberDecl = dynamic_cast<const ClassMemberDeclaration*>(decl.data());
   if( memberDecl ) {
     return stringFromAccess(memberDecl->accessPolicy());
   }
   return QString();
 }
 
 QString AbstractDeclarationNavigationContext::declarationName( const DeclarationPointer& decl ) const
 {
   if( NamespaceAliasDeclaration* alias = dynamic_cast<NamespaceAliasDeclaration*>(decl.data()) ) {
     if( alias->identifier().isEmpty() )
       return QLatin1String("using namespace ") + alias->importIdentifier().toString();
     else
       return QLatin1String("namespace ") + alias->identifier().toString() + QLatin1String(" = ") + alias->importIdentifier().toString();
   }
 
   if( !decl )
     return i18nc("A declaration that is unknown", "Unknown");
   else
     return prettyIdentifier(decl).toString();
 }
 
 QStringList AbstractDeclarationNavigationContext::declarationDetails(const DeclarationPointer& decl)
 {
   QStringList details;
   const AbstractFunctionDeclaration* function = dynamic_cast<const AbstractFunctionDeclaration*>(decl.data());
   const ClassMemberDeclaration* memberDecl = dynamic_cast<const ClassMemberDeclaration*>(decl.data());
   if( memberDecl ) {
     if( memberDecl->isMutable() )
       details << QStringLiteral("mutable");
     if( memberDecl->isRegister() )
       details << QStringLiteral("register");
     if( memberDecl->isStatic() )
       details << QStringLiteral("static");
     if( memberDecl->isAuto() )
       details << QStringLiteral("auto");
     if( memberDecl->isExtern() )
       details << QStringLiteral("extern");
     if( memberDecl->isFriend() )
       details << QStringLiteral("friend");
   }
 
   if( decl->isDefinition() )
     details << i18nc("tells if a declaration is defining the variable's value", "definition");
   if( decl->isExplicitlyDeleted() )
     details << QStringLiteral("deleted");
 
   if( memberDecl && memberDecl->isForwardDeclaration() )
     details << i18nc("as in c++ forward declaration", "forward");
 
   AbstractType::Ptr t(decl->abstractType());
   if( t ) {
     if( t->modifiers() & AbstractType::ConstModifier )
       details << i18nc("a variable that won't change, const", "constant");
     if( t->modifiers() & AbstractType::VolatileModifier )
       details << QStringLiteral("volatile");
   }
   if( function ) {
     if( function->isInline() )
       details << QStringLiteral("inline");
     if( function->isExplicit() )
       details << QStringLiteral("explicit");
     if( function->isVirtual() )
       details << QStringLiteral("virtual");
 
     const ClassFunctionDeclaration* classFunDecl = dynamic_cast<const ClassFunctionDeclaration*>(decl.data());
     if( classFunDecl ) {
       if( classFunDecl->isSignal() )
         details << QStringLiteral("signal");
       if( classFunDecl->isSlot() )
         details << QStringLiteral("slot");
       if( classFunDecl->isFinal() )
         details << QStringLiteral("final");
       if( classFunDecl->isConstructor() )
         details << QStringLiteral("constructor");
       if( classFunDecl->isDestructor() )
         details << QStringLiteral("destructor");
       if( classFunDecl->isConversionFunction() )
         details << QStringLiteral("conversion-function");
       if( classFunDecl->isAbstract() )
         details << QStringLiteral("abstract");
     }
   }
 
   return details;
 }
 
 QString AbstractDeclarationNavigationContext::declarationSizeInformation(const DeclarationPointer& decl)
 {
   // Note that ClassMemberDeclaration also includes ClassDeclaration, which uses the sizeOf and alignOf fields,
   // but normally leaves the bitOffsetOf unset (-1).
   const ClassMemberDeclaration* memberDecl = dynamic_cast<const ClassMemberDeclaration*>(decl.data());
   if (memberDecl && (memberDecl->bitOffsetOf() > 0 || memberDecl->sizeOf() > 0 || memberDecl->alignOf() > 0)) {
     QString sizeInfo = QStringLiteral("<p>");
 
     if (memberDecl->bitOffsetOf() >= 0) {
       const auto byteOffset = memberDecl->bitOffsetOf() / 8;
       const auto bitOffset = memberDecl->bitOffsetOf() % 8;
       const QString byteOffsetStr = i18np("1 Byte", "%1 Bytes", byteOffset);
       const QString bitOffsetStr = bitOffset ? i18np("1 Bit", "%1 Bits", bitOffset) : QString();
       sizeInfo += i18n("offset in parent: %1", bitOffset ? i18nc("%1: bytes, %2: bits", "%1, %2", byteOffsetStr, bitOffsetStr) : byteOffsetStr) + QLatin1String("; ");
     }
 
     if (memberDecl->sizeOf() >= 0) {
       sizeInfo += i18n("size: %1 Bytes", memberDecl->sizeOf()) + QLatin1String("; ");
     }
 
     if (memberDecl->alignOf() >= 0) {
       sizeInfo += i18n("aligned to: %1 Bytes", memberDecl->alignOf());
     }
 
     sizeInfo += QStringLiteral("</p>");
 
     return sizeInfo;
   }
   return QString();
 }
 
 }
diff --git a/kdevplatform/language/duchain/navigation/usescollector.cpp b/kdevplatform/language/duchain/navigation/usescollector.cpp
index 65c6105417..7261a2ee98 100644
--- a/kdevplatform/language/duchain/navigation/usescollector.cpp
+++ b/kdevplatform/language/duchain/navigation/usescollector.cpp
@@ -1,430 +1,430 @@
 /*
    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 "usescollector.h"
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/types/indexedtype.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <backgroundparser/parsejob.h>
 #include <backgroundparser/backgroundparser.h>
 #include "../classmemberdeclaration.h"
 #include "../abstractfunctiondeclaration.h"
 #include "../functiondefinition.h"
 #include <debug.h>
 #include <interfaces/iuicontroller.h>
 #include <codegen/coderepresentation.h>
 #include <KLocalizedString>
 
 using namespace KDevelop;
 
 ///@todo make this language-neutral
 static Identifier destructorForName(const Identifier& name) {
   QString str = name.identifier().str();
   if(str.startsWith(QLatin1Char('~')))
     return Identifier(str);
   return Identifier(QLatin1Char('~') + str);
 }
 
 ///@todo Only collect uses within currently loaded projects
 
 template<class ImportanceChecker>
 void collectImporters(ImportanceChecker& checker, ParsingEnvironmentFile* current, QSet<ParsingEnvironmentFile*>& visited, QSet<ParsingEnvironmentFile*>& collected) {
 
   //Ignore proxy-contexts while collecting. Those build a parallel and much more complicated structure.
   if(current->isProxyContext())
     return;
 
   if(visited.contains(current))
     return;
 
   visited.insert(current);
   if(checker(current))
     collected.insert(current);
 
   foreach(const ParsingEnvironmentFilePointer& importer, current->importers())
     if(importer.data())
       collectImporters(checker, importer.data(), visited, collected);
     else
       qCDebug(LANGUAGE) << "missing environment-file, strange";
 }
 
 ///The returned set does not include the file itself
 ///@param visited should be empty on each call, used to prevent endless recursion
 void allImportedFiles(ParsingEnvironmentFilePointer file, QSet<IndexedString>& set, QSet<ParsingEnvironmentFilePointer>& visited) {
   foreach(const ParsingEnvironmentFilePointer &import, file->imports()) {
     if(!import) {
       qCDebug(LANGUAGE) << "warning: missing import";
       continue;
     }
     if(!visited.contains(import)) {
       visited.insert(import);
       set.insert(import->url());
       allImportedFiles(import, set, visited);
     }
   }
 }
 
 void UsesCollector::setCollectConstructors(bool process) {
   m_collectConstructors = process;
 }
 
 void UsesCollector::setProcessDeclarations(bool process) {
   m_processDeclarations = process;
 }
 
 void UsesCollector::setCollectOverloads(bool collect) {
   m_collectOverloads = collect;
 }
 
 void UsesCollector::setCollectDefinitions(bool collect) {
   m_collectDefinitions = collect;
 }
 
 QList<IndexedDeclaration> UsesCollector::declarations() {
   return m_declarations;
 }
 
 bool UsesCollector::isReady() const {
   return m_waitForUpdate.size() == m_updateReady.size();
 }
 
 bool UsesCollector::shouldRespectFile(const IndexedString& document)
 {
   return (bool)ICore::self()->projectController()->findProjectForUrl(document.toUrl()) || (bool)ICore::self()->documentController()->documentForUrl(document.toUrl());
 }
 
 struct ImportanceChecker {
   explicit ImportanceChecker(UsesCollector& collector) : m_collector(collector) {
   }
   bool operator ()(ParsingEnvironmentFile* file) {
     return m_collector.shouldRespectFile(file->url());
   }
   UsesCollector& m_collector;
 };
 
 void UsesCollector::startCollecting() {
     DUChainReadLocker lock(DUChain::lock());
 
     if(Declaration* decl = m_declaration.data()) {
 
         if(m_collectDefinitions) {
           if(FunctionDefinition* def = dynamic_cast<FunctionDefinition*>(decl)) {
           //Jump from definition to declaration
             Declaration* declaration = def->declaration();
             if(declaration)
               decl = declaration;
           }
         }
 
         ///Collect all overloads into "decls"
         QList<Declaration*> decls;
 
         if(m_collectOverloads && decl->context()->owner() && decl->context()->type() == DUContext::Class) {
           //First find the overridden base, and then all overriders of that base.
-          while(Declaration* overridden = DUChainUtils::getOverridden(decl))
+          while(Declaration* overridden = DUChainUtils::overridden(decl))
             decl = overridden;
           uint maxAllowedSteps = 10000;
-          decls += DUChainUtils::getOverriders( decl->context()->owner(), decl, maxAllowedSteps );
+          decls += DUChainUtils::overriders( decl->context()->owner(), decl, maxAllowedSteps );
           if(maxAllowedSteps == 10000) {
             ///@todo Fail!
           }
         }
 
         decls << decl;
 
         ///Collect all "parsed versions" or forward-declarations etc. here, into allDeclarations
         QSet<IndexedDeclaration> allDeclarations;
 
         foreach(Declaration* overload, decls) {
           m_declarations = DUChainUtils::collectAllVersions(overload);
           foreach(const IndexedDeclaration &d, m_declarations) {
             if(!d.data() || d.data()->id() != overload->id())
               continue;
             allDeclarations.insert(d);
 
             if(m_collectConstructors && d.data() && d.data()->internalContext() && d.data()->internalContext()->type() == DUContext::Class) {
               const QList<Declaration*> constructors = d.data()->internalContext()->findLocalDeclarations(d.data()->identifier(), CursorInRevision::invalid(), nullptr, AbstractType::Ptr(), DUContext::OnlyFunctions);
               for (Declaration* constructor : constructors) {
                 ClassFunctionDeclaration* classFun = dynamic_cast<ClassFunctionDeclaration*>(constructor);
                 if(classFun && classFun->isConstructor())
                   allDeclarations.insert(IndexedDeclaration(constructor));
               }
 
               Identifier destructorId = destructorForName(d.data()->identifier());
 
               const QList<Declaration*> destructors = d.data()->internalContext()->findLocalDeclarations(destructorId, CursorInRevision::invalid(), nullptr, AbstractType::Ptr(), DUContext::OnlyFunctions);
               for (Declaration* destructor : destructors) {
                 ClassFunctionDeclaration* classFun = dynamic_cast<ClassFunctionDeclaration*>(destructor);
                 if(classFun && classFun->isDestructor())
                   allDeclarations.insert(IndexedDeclaration(destructor));
               }
             }
           }
         }
 
         ///Collect definitions for declarations
         if(m_collectDefinitions) {
           foreach(const IndexedDeclaration d, allDeclarations) {
             Declaration* definition = FunctionDefinition::definition(d.data());
             if(definition) {
                 qCDebug(LANGUAGE) << "adding definition";
               allDeclarations.insert(IndexedDeclaration(definition));
             }
           }
         }
 
         m_declarations.clear();
 
         ///Step 4: Copy allDeclarations into m_declarations, build top-context list, etc.
         QList<ReferencedTopDUContext> candidateTopContexts;
         candidateTopContexts.reserve(allDeclarations.size());
         m_declarations.reserve(allDeclarations.size());
         foreach(const IndexedDeclaration d, allDeclarations) {
           m_declarations << d;
           m_declarationTopContexts.insert(d.indexedTopContext());
           //We only collect declarations with the same type here..
           candidateTopContexts << d.indexedTopContext().data();
         }
 
         ImportanceChecker checker(*this);
 
         QSet<ParsingEnvironmentFile*> visited;
         QSet<ParsingEnvironmentFile*> collected;
 
         qCDebug(LANGUAGE) << "count of source candidate top-contexts:" << candidateTopContexts.size();
 
         ///We use ParsingEnvironmentFile to collect all the relevant importers, because loading those is very cheap, compared
         ///to loading a whole TopDUContext.
         if(decl->inSymbolTable()) {
           //The declaration can only be used from other contexts if it is in the symbol table
           foreach(const ReferencedTopDUContext &top, candidateTopContexts) {
             if(top->parsingEnvironmentFile()) {
               collectImporters(checker, top->parsingEnvironmentFile().data(), visited, collected);
               //In C++, visibility is not handled strictly through the import-structure.
               //It may happen that an object is visible because of an earlier include.
               //We can not perfectly handle that, but we can at least handle it if the header includes
               //the header that contains the declaration. That header may be parsed empty due to header-guards,
               //but we still need to pick it up here.
               const QList<ParsingEnvironmentFilePointer> allVersions = DUChain::self()->allEnvironmentFiles(top->url());
               for (const ParsingEnvironmentFilePointer& version : allVersions)
                 collectImporters(checker, version.data(), visited, collected);
             }
           }
         }
         KDevelop::ParsingEnvironmentFile* file=decl->topContext()->parsingEnvironmentFile().data();
         if(!file)
           return;
 
         if(checker(file))
           collected.insert(file);
 
         {
           QSet<ParsingEnvironmentFile*> filteredCollected;
           QMap<IndexedString, bool> grepCache;
           // Filter the collected files by performing a grep
           foreach(ParsingEnvironmentFile* file, collected)
           {
             IndexedString url = file->url();
             QMap< IndexedString, bool >::iterator grepCacheIt = grepCache.find(url);
             if(grepCacheIt == grepCache.end())
             {
               CodeRepresentation::Ptr repr = KDevelop::createCodeRepresentation( url );
               if(repr)
               {
                 QVector<KTextEditor::Range> found = repr->grep(decl->identifier().identifier().str());
                 grepCacheIt = grepCache.insert(url, !found.isEmpty());
               }
             }
             if(grepCacheIt.value())
               filteredCollected << file;
           }
           qCDebug(LANGUAGE) << "Collected contexts for full re-parse, before filtering: " << collected.size() << " after filtering: " << filteredCollected.size();
           collected = filteredCollected;
         }
 
         ///We have all importers now. However since we can tell parse-jobs to also update all their importers, we only need to
         ///update the "root" top-contexts that open the whole set with their imports.
         QSet<IndexedString> rootFiles;
         QSet<IndexedString> allFiles;
         foreach(ParsingEnvironmentFile* importer, collected) {
           QSet<IndexedString> allImports;
           QSet<ParsingEnvironmentFilePointer> visited;
           allImportedFiles(ParsingEnvironmentFilePointer(importer), allImports, visited);
           //Remove all files from the "root" set that are imported by this one
           ///@todo more intelligent
           rootFiles -= allImports;
           allFiles += allImports;
           allFiles.insert(importer->url());
           rootFiles.insert(importer->url());
         }
 
         emit maximumProgressSignal(rootFiles.size());
         maximumProgress(rootFiles.size());
 
         //If we used the AllDeclarationsContextsAndUsesRecursive flag here, we would compute way too much. This way we only
         //set the minimum-features selectively on the files we really require them on.
         foreach(ParsingEnvironmentFile* file, collected)
           m_staticFeaturesManipulated.insert(file->url());
         m_staticFeaturesManipulated.insert(decl->url());
 
         foreach(const IndexedString &file, m_staticFeaturesManipulated)
           ParseJob::setStaticMinimumFeatures(file, TopDUContext::AllDeclarationsContextsAndUses);
 
         m_waitForUpdate = rootFiles;
 
         foreach(const IndexedString &file, rootFiles) {
           qCDebug(LANGUAGE) << "updating root file:" << file.str();
           DUChain::self()->updateContextForUrl(file, TopDUContext::AllDeclarationsContextsAndUses, this);
         }
 
     }else{
         emit maximumProgressSignal(0);
         maximumProgress(0);
     }
 }
 
 void UsesCollector::maximumProgress(uint max) {
   Q_UNUSED(max);
 }
 
 UsesCollector::UsesCollector(IndexedDeclaration declaration) : m_declaration(declaration), m_collectOverloads(true), m_collectDefinitions(true), m_collectConstructors(false), m_processDeclarations(true) {
 }
 
 UsesCollector::~UsesCollector() {
   ICore::self()->languageController()->backgroundParser()->revertAllRequests(this);
 
   foreach(const IndexedString &file, m_staticFeaturesManipulated)
     ParseJob::unsetStaticMinimumFeatures(file, TopDUContext::AllDeclarationsContextsAndUses);
 }
 
 
 void UsesCollector::progress(uint processed, uint total) {
   Q_UNUSED(processed);
   Q_UNUSED(total);
 }
 
 void UsesCollector::updateReady(const KDevelop::IndexedString& url, KDevelop::ReferencedTopDUContext topContext) {
 
   DUChainReadLocker lock(DUChain::lock());
 
   if(!topContext) {
     qCDebug(LANGUAGE) << "failed updating" << url.str();
   }else{
     if(topContext->parsingEnvironmentFile() && topContext->parsingEnvironmentFile()->isProxyContext()) {
       ///Use the attached content-context instead
       foreach(const DUContext::Import &import, topContext->importedParentContexts()) {
         if(import.context(nullptr) && import.context(nullptr)->topContext()->parsingEnvironmentFile() && !import.context(nullptr)->topContext()->parsingEnvironmentFile()->isProxyContext()) {
           if((import.context(nullptr)->topContext()->features() & TopDUContext::AllDeclarationsContextsAndUses)) {
             ReferencedTopDUContext newTop(import.context(nullptr)->topContext());
             topContext = newTop;
             break;
           }
         }
       }
       if(topContext->parsingEnvironmentFile() && topContext->parsingEnvironmentFile()->isProxyContext()) {
         qCDebug(LANGUAGE) << "got bad proxy-context for" << url.str();
         topContext = nullptr;
       }
 
     }
   }
 
   if(m_waitForUpdate.contains(url) && !m_updateReady.contains(url)) {
     m_updateReady << url;
     m_checked.clear();
 
 
     emit progressSignal(m_updateReady.size(), m_waitForUpdate.size());
     progress(m_updateReady.size(), m_waitForUpdate.size());
   }
 
   if(!topContext || !topContext->parsingEnvironmentFile()) {
     qCDebug(LANGUAGE) << "bad top-context";
     return;
   }
 
   if(!m_staticFeaturesManipulated.contains(url))
     return; //Not interesting
 
   if(!(topContext->features() & TopDUContext::AllDeclarationsContextsAndUses)) {
       ///@todo With simplified environment-matching, the same file may have been imported multiple times,
       ///while only one of  those was updated. We have to check here whether this file is just such an import,
       ///or whether we work on with it.
       ///@todo We will lose files that were edited right after their update here.
       qCWarning(LANGUAGE) << "WARNING: context" << topContext->url().str() << "does not have the required features!!";
       ICore::self()->uiController()->showErrorMessage(QLatin1String("Updating ") + ICore::self()->projectController()->prettyFileName(topContext->url().toUrl(), KDevelop::IProjectController::FormatPlain) + QLatin1String(" failed!"), 5);
       return;
   }
 
   if(topContext->parsingEnvironmentFile()->needsUpdate()) {
       qCWarning(LANGUAGE) << "WARNING: context" << topContext->url().str() << "is not up to date!";
       ICore::self()->uiController()->showErrorMessage(i18n("%1 still needs an update!", ICore::self()->projectController()->prettyFileName(topContext->url().toUrl(), KDevelop::IProjectController::FormatPlain)), 5);
 //       return;
   }
 
 
     IndexedTopDUContext indexed(topContext.data());
     if(m_checked.contains(indexed))
       return;
 
     if(!topContext.data()) {
       qCDebug(LANGUAGE) << "updated top-context is zero:" << url.str();
       return;
     }
 
     m_checked.insert(indexed);
 
     if(m_declaration.data() && ((m_processDeclarations && m_declarationTopContexts.contains(indexed)) ||
                                     DUChainUtils::contextHasUse(topContext.data(), m_declaration.data()))) {
       if(!m_processed.contains(topContext->url())) {
         m_processed.insert(topContext->url());
         lock.unlock();
         emit processUsesSignal(topContext);
         processUses(topContext);
         lock.lock();
       }
     } else {
       if(!m_declaration.data()) {
         qCDebug(LANGUAGE) << "declaration has become invalid";
       }
     }
 
     QList<KDevelop::ReferencedTopDUContext> imports;
 
     foreach(const DUContext::Import &imported, topContext->importedParentContexts())
       if(imported.context(nullptr) && imported.context(nullptr)->topContext())
       imports << KDevelop::ReferencedTopDUContext(imported.context(nullptr)->topContext());
 
     foreach(const KDevelop::ReferencedTopDUContext &import, imports) {
       IndexedString url = import->url();
       lock.unlock();
       updateReady(url, import);
       lock.lock();
     }
 }
 
 IndexedDeclaration UsesCollector::declaration() const {
   return m_declaration;
 }
diff --git a/kdevplatform/language/duchain/persistentsymboltable.cpp b/kdevplatform/language/duchain/persistentsymboltable.cpp
index 8a82c70c5c..4ae4c595e4 100644
--- a/kdevplatform/language/duchain/persistentsymboltable.cpp
+++ b/kdevplatform/language/duchain/persistentsymboltable.cpp
@@ -1,422 +1,422 @@
 /* This file is part of KDevelop
     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 "persistentsymboltable.h"
 
 #include <QHash>
 
 #include "declaration.h"
 #include "declarationid.h"
 #include "appendedlist.h"
 #include "serialization/itemrepository.h"
 #include "identifier.h"
 #include "ducontext.h"
 #include "topducontext.h"
 #include "duchain.h"
 #include "duchainlock.h"
 #include <util/embeddedfreetree.h>
 
 //For now, just _always_ use the cache
 const uint MinimumCountForCache = 1;
 
 namespace {
 QDebug fromTextStream(const QTextStream& out) { if (out.device()) return {out.device()}; return {out.string()}; }
 }
 
 namespace KDevelop {
 
 Utils::BasicSetRepository* RecursiveImportCacheRepository::repository() {
   static Utils::BasicSetRepository recursiveImportCacheRepositoryObject(QStringLiteral("Recursive Imports Cache"), nullptr, false);
   return &recursiveImportCacheRepositoryObject;
 }
 
 DEFINE_LIST_MEMBER_HASH(PersistentSymbolTableItem, declarations, IndexedDeclaration)
 
 class PersistentSymbolTableItem {
   public:
   PersistentSymbolTableItem() : centralFreeItem(-1) {
     initializeAppendedLists();
   }
   PersistentSymbolTableItem(const PersistentSymbolTableItem& rhs, bool dynamic = true) : id(rhs.id), centralFreeItem(rhs.centralFreeItem) {
     initializeAppendedLists(dynamic);
     copyListsFrom(rhs);
   }
   
   ~PersistentSymbolTableItem() {
     freeAppendedLists();
   }
   
   inline unsigned int hash() const {
     //We only compare the declaration. This allows us implementing a map, although the item-repository
     //originally represents a set.
-    return id.getIndex();
+    return id.index();
   }
   
   unsigned int itemSize() const {
     return dynamicSize();
   }
   
   uint classSize() const {
     return sizeof(PersistentSymbolTableItem);
   }
   
   IndexedQualifiedIdentifier id;
   int centralFreeItem;
   
   START_APPENDED_LISTS(PersistentSymbolTableItem);
   APPENDED_LIST_FIRST(PersistentSymbolTableItem, IndexedDeclaration, declarations);
   END_APPENDED_LISTS(PersistentSymbolTableItem, declarations);
 };
 
 class PersistentSymbolTableRequestItem {
   public:
   
   PersistentSymbolTableRequestItem(const PersistentSymbolTableItem& item) : m_item(item) {
   }
   enum {
     AverageSize = 30 //This should be the approximate average size of an Item
   };
 
   unsigned int hash() const {
     return m_item.hash();
   }
   
   uint itemSize() const {
       return m_item.itemSize();
   }
 
   void createItem(PersistentSymbolTableItem* item) const {
     new (item) PersistentSymbolTableItem(m_item, false);
   }
   
   static void destroy(PersistentSymbolTableItem* item, KDevelop::AbstractItemRepository&) {
     item->~PersistentSymbolTableItem();
   }
 
   static bool persistent(const PersistentSymbolTableItem*) {
     return true; //Nothing to do
   }
   
   bool equals(const PersistentSymbolTableItem* item) const {
     return m_item.id == item->id;
   }
   
   const PersistentSymbolTableItem& m_item;
 };
 
 template<class ValueType>
 struct CacheEntry {
   
   typedef KDevVarLengthArray<ValueType> Data;
   typedef QHash<TopDUContext::IndexedRecursiveImports, Data > DataHash;
   
   DataHash m_hash;
 };
 
 class PersistentSymbolTablePrivate
 {
 public:
 
   PersistentSymbolTablePrivate() : m_declarations(QStringLiteral("Persistent Declaration Table")) {
   }
   //Maps declaration-ids to declarations
   ItemRepository<PersistentSymbolTableItem, PersistentSymbolTableRequestItem, true, false> m_declarations;
   
   
   QHash<IndexedQualifiedIdentifier, CacheEntry<IndexedDeclaration> > m_declarationsCache;
   
   //We cache the imports so the currently used nodes are very close in memory, which leads to much better CPU cache utilization
   QHash<TopDUContext::IndexedRecursiveImports, PersistentSymbolTable::CachedIndexedRecursiveImports> m_importsCache;
 };
 
 void PersistentSymbolTable::clearCache()
 {
   ENSURE_CHAIN_WRITE_LOCKED
   {
     QMutexLocker lock(d->m_declarations.mutex());
     d->m_importsCache.clear();
     d->m_declarationsCache.clear();
   }
 }
 
 PersistentSymbolTable::PersistentSymbolTable() : d(new PersistentSymbolTablePrivate())
 {
 }
 
 PersistentSymbolTable::~PersistentSymbolTable()
 {
   //Workaround for a strange destruction-order related crash duing shutdown
   //We just let the data leak. This doesn't hurt, as there is no meaningful destructors.
   // TODO: analyze and fix it
 //   delete d;
 }
 
 void PersistentSymbolTable::addDeclaration(const IndexedQualifiedIdentifier& id, const IndexedDeclaration& declaration)
 {
   QMutexLocker lock(d->m_declarations.mutex());
   ENSURE_CHAIN_WRITE_LOCKED
   
   d->m_declarationsCache.remove(id);
   
   PersistentSymbolTableItem item;
   item.id = id;
   PersistentSymbolTableRequestItem request(item);
   
   uint index = d->m_declarations.findIndex(item);
   
   if(index) {
     //Check whether the item is already in the mapped list, else copy the list into the new created item
     const PersistentSymbolTableItem* oldItem = d->m_declarations.itemFromIndex(index);
     
     EmbeddedTreeAlgorithms<IndexedDeclaration, IndexedDeclarationHandler> alg(oldItem->declarations(), oldItem->declarationsSize(), oldItem->centralFreeItem);
     
     if(alg.indexOf(declaration) != -1)
       return;
     
     DynamicItem<PersistentSymbolTableItem, true> editableItem = d->m_declarations.dynamicItemFromIndex(index);
     
     EmbeddedTreeAddItem<IndexedDeclaration, IndexedDeclarationHandler> add(const_cast<IndexedDeclaration*>(editableItem->declarations()), editableItem->declarationsSize(), editableItem->centralFreeItem, declaration);
     
     uint newSize = add.newItemCount();
     if(newSize != editableItem->declarationsSize()) {
       //We need to resize. Update and fill the new item, and delete the old item.
       item.declarationsList().resize(newSize);
       add.transferData(item.declarationsList().data(), newSize, &item.centralFreeItem);
       
       d->m_declarations.deleteItem(index);
       Q_ASSERT(!d->m_declarations.findIndex(request));
     }else{
       //We're fine, the item could be added to the existing list
       return;
     }
   }else{
     item.declarationsList().append(declaration);
   }
 
   //This inserts the changed item
   d->m_declarations.index(request);
 }
 
 void PersistentSymbolTable::removeDeclaration(const IndexedQualifiedIdentifier& id, const IndexedDeclaration& declaration)
 {
   QMutexLocker lock(d->m_declarations.mutex());
   ENSURE_CHAIN_WRITE_LOCKED
   
   d->m_declarationsCache.remove(id);
   Q_ASSERT(!d->m_declarationsCache.contains(id));
   
   PersistentSymbolTableItem item;
   item.id = id;
   PersistentSymbolTableRequestItem request(item);
   
   uint index = d->m_declarations.findIndex(item);
   
   if(index) {
     //Check whether the item is already in the mapped list, else copy the list into the new created item
     const PersistentSymbolTableItem* oldItem = d->m_declarations.itemFromIndex(index);
     
     EmbeddedTreeAlgorithms<IndexedDeclaration, IndexedDeclarationHandler> alg(oldItem->declarations(), oldItem->declarationsSize(), oldItem->centralFreeItem);
     
     if(alg.indexOf(declaration) == -1)
       return;
     
     DynamicItem<PersistentSymbolTableItem, true> editableItem = d->m_declarations.dynamicItemFromIndex(index);
     
     EmbeddedTreeRemoveItem<IndexedDeclaration, IndexedDeclarationHandler> remove(const_cast<IndexedDeclaration*>(editableItem->declarations()), editableItem->declarationsSize(), editableItem->centralFreeItem, declaration);
     
     uint newSize = remove.newItemCount();
     if(newSize != editableItem->declarationsSize()) {
       //We need to resize. Update and fill the new item, and delete the old item.
       item.declarationsList().resize(newSize);
       remove.transferData(item.declarationsList().data(), newSize, &item.centralFreeItem);
       
       d->m_declarations.deleteItem(index);
       Q_ASSERT(!d->m_declarations.findIndex(request));
     }else{
       //We're fine, the item could be added to the existing list
       return;
     }
   }
 
   //This inserts the changed item
   if(item.declarationsSize())
     d->m_declarations.index(request);
 }
 
 struct DeclarationCacheVisitor {
   explicit DeclarationCacheVisitor(KDevVarLengthArray<IndexedDeclaration>& _cache) : cache(_cache) {
   }
   
   bool operator()(const IndexedDeclaration& decl) const {
     cache.append(decl);
     return true;
   }
   
   KDevVarLengthArray<IndexedDeclaration>& cache;
 };
 
-PersistentSymbolTable::FilteredDeclarationIterator PersistentSymbolTable::getFilteredDeclarations(const IndexedQualifiedIdentifier& id, const TopDUContext::IndexedRecursiveImports& visibility) const {
+PersistentSymbolTable::FilteredDeclarationIterator PersistentSymbolTable::filteredDeclarations(const IndexedQualifiedIdentifier& id, const TopDUContext::IndexedRecursiveImports& visibility) const {
   
   QMutexLocker lock(d->m_declarations.mutex());
   ENSURE_CHAIN_READ_LOCKED
   
-  Declarations decls = getDeclarations(id).iterator();
+  Declarations decls = declarations(id).iterator();
   
   CachedIndexedRecursiveImports cachedImports;
   
   QHash<TopDUContext::IndexedRecursiveImports, CachedIndexedRecursiveImports>::const_iterator it = d->m_importsCache.constFind(visibility);
   if(it != d->m_importsCache.constEnd()) {
     cachedImports = *it;
   }else{
     cachedImports = CachedIndexedRecursiveImports(visibility.set().stdSet());
     d->m_importsCache.insert(visibility, cachedImports);
   }
   
   if(decls.dataSize() > MinimumCountForCache)
   {
     //Do visibility caching
     CacheEntry<IndexedDeclaration>& cached(d->m_declarationsCache[id]);
     CacheEntry<IndexedDeclaration>::DataHash::const_iterator cacheIt = cached.m_hash.constFind(visibility);
     if(cacheIt != cached.m_hash.constEnd())
       return FilteredDeclarationIterator(Declarations::Iterator(cacheIt->constData(), cacheIt->size(), -1), cachedImports);
 
     CacheEntry<IndexedDeclaration>::DataHash::iterator insertIt = cached.m_hash.insert(visibility, KDevVarLengthArray<IndexedDeclaration>());
     
     KDevVarLengthArray<IndexedDeclaration>& cache(*insertIt);
     
     {
       typedef ConvenientEmbeddedSetTreeFilterVisitor<IndexedDeclaration, IndexedDeclarationHandler, IndexedTopDUContext, CachedIndexedRecursiveImports, DeclarationTopContextExtractor, DeclarationCacheVisitor> FilteredDeclarationCacheVisitor;
     
       //The visitor visits all the declarations from within its constructor
       DeclarationCacheVisitor v(cache);
       FilteredDeclarationCacheVisitor visitor(v, decls.iterator(), cachedImports);
     }
     
     return FilteredDeclarationIterator(Declarations::Iterator(cache.constData(), cache.size(), -1), cachedImports, true);
   }else{
     return FilteredDeclarationIterator(decls.iterator(), cachedImports);
   }
 }
 
-PersistentSymbolTable::Declarations PersistentSymbolTable::getDeclarations(const IndexedQualifiedIdentifier& id) const {
+PersistentSymbolTable::Declarations PersistentSymbolTable::declarations(const IndexedQualifiedIdentifier& id) const {
   QMutexLocker lock(d->m_declarations.mutex());
   ENSURE_CHAIN_READ_LOCKED
   
   PersistentSymbolTableItem item;
   item.id = id;
   
   uint index = d->m_declarations.findIndex(item);
   
   if(index) {
     const PersistentSymbolTableItem* repositoryItem = d->m_declarations.itemFromIndex(index);
     return PersistentSymbolTable::Declarations(repositoryItem->declarations(), repositoryItem->declarationsSize(), repositoryItem->centralFreeItem);
   }else{
     return PersistentSymbolTable::Declarations();
   }
 }
 
 void PersistentSymbolTable::declarations(const IndexedQualifiedIdentifier& id, uint& countTarget, const IndexedDeclaration*& declarationsTarget) const
 {
   QMutexLocker lock(d->m_declarations.mutex());
   ENSURE_CHAIN_READ_LOCKED
   
   PersistentSymbolTableItem item;
   item.id = id;
   
   uint index = d->m_declarations.findIndex(item);
   
   if(index) {
     const PersistentSymbolTableItem* repositoryItem = d->m_declarations.itemFromIndex(index);
     countTarget = repositoryItem->declarationsSize();
     declarationsTarget = repositoryItem->declarations();
   }else{
     countTarget = 0;
     declarationsTarget = nullptr;
   }
 }
 
 struct DebugVisitor
 {
   explicit DebugVisitor(const QTextStream& _out)
     : out(_out)
   {
   }
 
   bool operator() (const PersistentSymbolTableItem* item) {
     QDebug qout = fromTextStream(out);
     QualifiedIdentifier id(item->id.identifier());
     if(identifiers.contains(id)) {
       qout << "identifier" << id.toString() << "appears for" << identifiers[id] << "th time";
     }
     
     ++identifiers[id];
     
     for(uint a = 0; a < item->declarationsSize(); ++a) {
       IndexedDeclaration decl(item->declarations()[a]);
       if(!decl.isDummy()) {
         if(declarations.contains(decl)) {
           qout << "declaration found for multiple identifiers. Previous identifier:" << declarations[decl].toString() << "current identifier:" << id.toString() << endl;
         }else{
           declarations.insert(decl, id);
         }
       }
       if(decl.data() && decl.data()->qualifiedIdentifier() != item->id.identifier()) {
         qout << decl.data()->url().str() << "declaration" << decl.data()->qualifiedIdentifier() << "is registered as" << item->id.identifier() << endl;
       }
       
       const QString url = IndexedTopDUContext(decl.topContextIndex()).url().str();
       if(!decl.data() && !decl.isDummy()) {
         qout << "Item in symbol-table is invalid:" << id.toString() << "- localIndex:" << decl.localIndex() << "- url:" << url << endl;
       } else {
         qout << "Item in symbol-table:" << id.toString() << "- localIndex:" << decl.localIndex() << "- url:" << url;
         if (auto d = decl.data()) {
           qout << "- range:" << d->range();
         } else {
           qout << "- null declaration";
         }
         qout << endl;
       }
     }
     return true;
   }
 
   const QTextStream& out;
   QHash<QualifiedIdentifier, uint> identifiers;
   QHash<IndexedDeclaration, QualifiedIdentifier> declarations;
 };
 
 void PersistentSymbolTable::dump(const QTextStream& out)
 {
   {
     QMutexLocker lock(d->m_declarations.mutex());
     
     QDebug qout = fromTextStream(out);
     DebugVisitor v(out);
     d->m_declarations.visitAllItems(v);
 
     qout << "Statistics:" << endl;
     qout << d->m_declarations.statistics() << endl;
   }
 }
 
 PersistentSymbolTable& PersistentSymbolTable::self() {
   static PersistentSymbolTable ret;
   return ret;
 }
 
 }
diff --git a/kdevplatform/language/duchain/persistentsymboltable.h b/kdevplatform/language/duchain/persistentsymboltable.h
index b60eee731a..7e8a966167 100644
--- a/kdevplatform/language/duchain/persistentsymboltable.h
+++ b/kdevplatform/language/duchain/persistentsymboltable.h
@@ -1,145 +1,145 @@
 /* This file is part of KDevelop
     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 KDEVPLATFORM_PERSISTENTSYMBOLTABLE_H
 #define KDEVPLATFORM_PERSISTENTSYMBOLTABLE_H
 
 #include <util/convenientfreelist.h>
 #include <language/util/setrepository.h>
 #include <language/languageexport.h>
 #include "indexeddeclaration.h"
 #include "ducontext.h"
 #include "topducontext.h"
 
 namespace KDevelop {
 
 class Declaration;
 class IndexedDeclaration;
 class IndexedDUContext;
 class DeclarationId;
 class TopDUContext;
 class IndexedQualifiedIdentifier;
 
 ///@todo move into own header
 class KDEVPLATFORMLANGUAGE_EXPORT IndexedDeclarationHandler {
     public:
     inline static int leftChild(const IndexedDeclaration& m_data) {
         return ((int)(m_data.dummyData().first))-1;
     }
     inline static void setLeftChild(IndexedDeclaration& m_data, int child) {
         m_data.setDummyData(qMakePair((uint)(child+1), m_data.dummyData().second));
     }
     inline static int rightChild(const IndexedDeclaration& m_data) {
         return ((int)m_data.dummyData().second)-1;
     }
     inline static void setRightChild(IndexedDeclaration& m_data, int child) {
         m_data.setDummyData(qMakePair(m_data.dummyData().first, (uint)(child+1)));
     }
     inline static void createFreeItem(IndexedDeclaration& data) {
         data = IndexedDeclaration();
         data.setIsDummy(true);
         data.setDummyData(qMakePair(0u, 0u)); //Since we subtract 1, this equals children -1, -1
     }
     //Copies this item into the given one
     inline static void copyTo(const IndexedDeclaration& m_data, IndexedDeclaration& data) {
         data = m_data;
     }
     
     inline static bool isFree(const IndexedDeclaration& m_data) {
         return m_data.isDummy();
     }
 
     inline static bool equals(const IndexedDeclaration& m_data, const IndexedDeclaration& rhs) {
       return m_data == rhs;
     }
 };
 
 
 struct DeclarationTopContextExtractor {
   inline static IndexedTopDUContext extract(const IndexedDeclaration& decl) {
     return decl.indexedTopContext();
   }
 };
 
 struct DUContextTopContextExtractor {
   inline static IndexedTopDUContext extract(const IndexedDUContext& ctx) {
     return ctx.indexedTopContext();
   }
 };
 
 struct KDEVPLATFORMLANGUAGE_EXPORT RecursiveImportCacheRepository {
   static Utils::BasicSetRepository* repository();
 };
 
 /**
  * Global symbol-table that is stored to disk, and allows retrieving declarations that currently are not loaded to memory.
  * */
   class KDEVPLATFORMLANGUAGE_EXPORT PersistentSymbolTable {
     public:
     /// Constructor.
     PersistentSymbolTable();
     /// Destructor.
     ~PersistentSymbolTable();
 
     ///Adds declaration @p declaration with id @p id to the symbol table
     ///@warning DUChain must be write locked
     void addDeclaration(const IndexedQualifiedIdentifier& id, const IndexedDeclaration& declaration);
 
     ///Adds declaration @p declaration with id @p id to the symbol table
     ///@warning DUChain must be write locked
     void removeDeclaration(const IndexedQualifiedIdentifier& id, const IndexedDeclaration& declaration);
 
     ///Retrieves all the declarations for a given IndexedQualifiedIdentifier in an efficient way.
     ///@param id The IndexedQualifiedIdentifier for which the declarations should be retrieved
     ///@param count A reference that will be filled with the count of retrieved declarations
     ///@param declarations A reference to a pointer, that will be filled with a pointer to the retrieved declarations.
     ///@warning DUChain must be read locked as long as the returned data is used
     void declarations(const IndexedQualifiedIdentifier& id, uint& count, const IndexedDeclaration*& declarations) const;
 
     typedef ConstantConvenientEmbeddedSet<IndexedDeclaration, IndexedDeclarationHandler> Declarations;
     
     ///Retrieves all the declarations for a given IndexedQualifiedIdentifier in an efficient way, and returns
     ///them in a structure that is more convenient than declarations().
     ///@param id The IndexedQualifiedIdentifier for which the declarations should be retrieved
     ///@warning DUChain must be read locked as long as the returned data is used
-    Declarations getDeclarations(const IndexedQualifiedIdentifier& id) const;
+    Declarations declarations(const IndexedQualifiedIdentifier& id) const;
 
     typedef Utils::StorableSet<IndexedTopDUContext, IndexedTopDUContextIndexConversion, RecursiveImportCacheRepository, true> CachedIndexedRecursiveImports;
     
     typedef ConvenientEmbeddedSetTreeFilterIterator<IndexedDeclaration, IndexedDeclarationHandler, IndexedTopDUContext, CachedIndexedRecursiveImports, DeclarationTopContextExtractor> FilteredDeclarationIterator;
     ///Retrieves an iterator to all declarations of the given id, filtered by the visilibity given through @a visibility
     ///This is very efficient since it uses a cache
     ///The returned iterator is valid as long as the duchain read lock is held
-    FilteredDeclarationIterator getFilteredDeclarations(const IndexedQualifiedIdentifier& id, const TopDUContext::IndexedRecursiveImports& visibility) const;
+    FilteredDeclarationIterator filteredDeclarations(const IndexedQualifiedIdentifier& id, const TopDUContext::IndexedRecursiveImports& visibility) const;
 
     static PersistentSymbolTable& self();
 
     //Very expensive: Checks for problems in the symbol table
     void dump(const QTextStream& out);
     
     //Clears the internal cache. Should be called regularly to save memory
     //The duchain must be read-locked
     void clearCache();
     
     private:
       // cannot use QScopedPointer yet, see comment in ~PersistentSymbolTable()
       class PersistentSymbolTablePrivate* const d;
   };
 }
 
 #endif
diff --git a/kdevplatform/language/duchain/problem.cpp b/kdevplatform/language/duchain/problem.cpp
index 47e9e7541c..11e385fca4 100644
--- a/kdevplatform/language/duchain/problem.cpp
+++ b/kdevplatform/language/duchain/problem.cpp
@@ -1,285 +1,285 @@
 /* This file is part of KDevelop
 Copyright 2007 Hamish Rodda <rodda@kde.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #include "problem.h"
 
 #include "duchainregister.h"
 #include "topducontextdynamicdata.h"
 #include "topducontext.h"
 #include "topducontextdata.h"
 #include "duchain.h"
 #include "duchainlock.h"
 
 #include <editor/documentrange.h>
 
 #include <interfaces/iassistant.h>
 #include <qtcompat_p.h>
 
 #include <KLocalizedString>
 
 namespace KDevelop {
 REGISTER_DUCHAIN_ITEM(Problem);
 DEFINE_LIST_MEMBER_HASH(ProblemData, diagnostics, LocalIndexedProblem)
 }
 
 using namespace KDevelop;
 
 LocalIndexedProblem::LocalIndexedProblem(const ProblemPointer& problem, const TopDUContext* top)
   : m_index(problem->m_indexInTopContext)
 {
     ENSURE_CHAIN_READ_LOCKED
     // ensure child problems are properly serialized before we serialize the parent problem
     // see below, the diagnostic size is kept in sync by the mutable API of Problem
     // the const cast is ugly but we don't really "change" the state as observed from the outside
     auto& serialized = const_cast<Problem*>(problem.data())->d_func_dynamic()->diagnosticsList();
     serialized.clear();
     serialized.reserve(problem->m_diagnostics.size());
     foreach(const ProblemPointer& child, problem->m_diagnostics) {
         serialized << LocalIndexedProblem(child, top);
     }
 
     if (!m_index) {
         m_index = top->m_dynamicData->allocateProblemIndex(problem);
     }
 }
 
 ProblemPointer LocalIndexedProblem::data(const TopDUContext* top) const
 {
   if (!m_index) {
     return {};
   }
-  return top->m_dynamicData->getProblemForIndex(m_index);
+  return top->m_dynamicData->problemForIndex(m_index);
 }
 
 Problem::Problem()
     : DUChainBase(*new ProblemData)
 {
     d_func_dynamic()->setClassId(this);
 }
 
 Problem::Problem(ProblemData& data)
     : DUChainBase(data)
 {
 }
 
 Problem::~Problem()
 {
 }
 
 TopDUContext* Problem::topContext() const
 {
     return m_topContext.data();
 }
 
 IndexedString Problem::url() const
 {
     return d_func()->url;
 }
 
 DocumentRange Problem::finalLocation() const
 {
     return DocumentRange(d_func()->url, d_func()->m_range.castToSimpleRange());
 }
 
 void Problem::setFinalLocation(const DocumentRange& location)
 {
     setRange(RangeInRevision::castFromSimpleRange(location));
     d_func_dynamic()->url = location.document;
 }
 
 IProblem::FinalLocationMode Problem::finalLocationMode() const
 {
     return d_func()->finalLocationMode;
 }
 
 void Problem::setFinalLocationMode(IProblem::FinalLocationMode mode)
 {
     d_func_dynamic()->finalLocationMode = mode;
 }
 
 void Problem::clearDiagnostics()
 {
     m_diagnostics.clear();
     // keep serialization in sync, see also LocalIndexedProblem ctor above
     d_func_dynamic()->diagnosticsList().clear();
 }
 
 QVector<IProblem::Ptr> Problem::diagnostics() const
 {
     QVector<IProblem::Ptr> vector;
 
     for (const auto& ptr : qAsConst(m_diagnostics)) {
         vector.push_back(ptr);
     }
 
     return vector;
 }
 
 void Problem::setDiagnostics(const QVector<IProblem::Ptr> &diagnostics)
 {
     clearDiagnostics();
 
     for (const IProblem::Ptr& problem : diagnostics) {
         addDiagnostic(problem);
     }
 }
 
 void Problem::addDiagnostic(const IProblem::Ptr &diagnostic)
 {
     Problem *problem = dynamic_cast<Problem*>(diagnostic.data());
     Q_ASSERT(problem != nullptr);
 
     ProblemPointer ptr(problem);
 
     m_diagnostics << ptr;
 }
 
 QString Problem::description() const
 {
     return d_func()->description.str();
 }
 
 void Problem::setDescription(const QString& description)
 {
     d_func_dynamic()->description = IndexedString(description);
 }
 
 QString Problem::explanation() const
 {
     return d_func()->explanation.str();
 }
 
 void Problem::setExplanation(const QString& explanation)
 {
     d_func_dynamic()->explanation = IndexedString(explanation);
 }
 
 IProblem::Source Problem::source() const
 {
     return d_func()->source;
 }
 
 void Problem::setSource(IProblem::Source source)
 {
     d_func_dynamic()->source = source;
 }
 
 QExplicitlySharedDataPointer<IAssistant> Problem::solutionAssistant() const
 {
     return {};
 }
 
 IProblem::Severity Problem::severity() const
 {
     return d_func()->severity;
 }
 
 void Problem::setSeverity(Severity severity)
 {
     d_func_dynamic()->severity = severity;
 }
 
 QString Problem::severityString() const
 {
     switch(severity()) {
         case IProblem::NoSeverity:
             return {};
         case IProblem::Error:
             return i18n("Error");
         case IProblem::Warning:
             return i18n("Warning");
         case IProblem::Hint:
             return i18n("Hint");
     }
     return QString();
 }
 
 QString Problem::sourceString() const
 {
     switch (source()) {
         case IProblem::Disk:
             return i18n("Disk");
         case IProblem::Preprocessor:
             return i18n("Preprocessor");
         case IProblem::Lexer:
             return i18n("Lexer");
         case IProblem::Parser:
             return i18n("Parser");
         case IProblem::DUChainBuilder:
             return i18n("Definition-Use Chain");
         case IProblem::SemanticAnalysis:
             return i18n("Semantic analysis");
         case IProblem::ToDo:
             return i18n("To-do");
         case IProblem::Unknown:
         default:
             return i18n("Unknown");
     }
 }
 
 QString Problem::toString() const
 {
     return i18nc("<severity>: <description> in <url>:[<range>]: <explanation> (found by <source>)",
                  "%1: %2 in %3:[(%4,%5),(%6,%7)]: %8 (found by %9)"
         , severityString()
         , description()
         , url().str()
         , range().start.line
         , range().start.column
         , range().end.line
         , range().end.column
         , (explanation().isEmpty() ? i18n("<no explanation>") : explanation())
         , sourceString());
 }
 
 void Problem::rebuildDynamicData(DUContext* parent, uint ownIndex)
 {
     auto top = dynamic_cast<TopDUContext*>(parent);
     Q_ASSERT(top);
 
     m_topContext = top;
     m_indexInTopContext = ownIndex;
 
     // deserialize child diagnostics here, as the top-context might get unloaded
     // but we still want to keep the child-diagnostics in-tact, as one would assume
     // a shared-ptr works.
     const auto data = d_func();
     m_diagnostics.reserve(data->diagnosticsSize());
     for (uint i = 0; i < data->diagnosticsSize(); ++i) {
         m_diagnostics << ProblemPointer(data->diagnostics()[i].data(top));
     }
 
     DUChainBase::rebuildDynamicData(parent, ownIndex);
 }
 
 QDebug operator<<(QDebug s, const Problem& problem)
 {
     s.nospace() << problem.toString();
     return s.space();
 }
 
 QDebug operator<<(QDebug s, const ProblemPointer& problem)
 {
     if (!problem) {
         s.nospace() << "<invalid problem>";
     } else {
         s.nospace() << problem->toString();
     }
     return s.space();
 }
diff --git a/kdevplatform/language/duchain/tests/test_duchain.cpp b/kdevplatform/language/duchain/tests/test_duchain.cpp
index d2b188ade3..1c95b6795f 100644
--- a/kdevplatform/language/duchain/tests/test_duchain.cpp
+++ b/kdevplatform/language/duchain/tests/test_duchain.cpp
@@ -1,1034 +1,1034 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2011-2013 Milian Wolff <mail@milianw.de>
  * Copyright 2006 Hamish Rodda <rodda@kde.org>
  * Copyright 2007-2009 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "test_duchain.h"
 
 #include <QTest>
 #include <QElapsedTimer>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/codemodel.h>
 #include <language/duchain/types/typesystemdata.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/typeregister.h>
 #include <language/duchain/declarationdata.h>
 #include <language/duchain/duchainregister.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/parsingenvironment.h>
 
 #include <language/codegen/coderepresentation.h>
 
 #include <language/util/setrepository.h>
 #include <language/util/basicsetrepository.h>
 
 // #include <typeinfo>
 #include <set>
 #include <algorithm>
 #include <iterator> // needed for std::insert_iterator on windows
 #include <QThread>
 
 //Extremely slow
 // #define TEST_NORMAL_IMPORTS
 
 QTEST_MAIN(TestDUChain)
 
 using namespace KDevelop;
 using namespace Utils;
 
 typedef BasicSetRepository::Index Index;
 
 struct Timer
 {
   Timer()
   {
     m_timer.start();
   }
   qint64 elapsed()
   {
     return m_timer.nsecsElapsed();
   }
   QElapsedTimer m_timer;
 };
 
 void TestDUChain::initTestCase()
 {
   AutoTestShell::init();
   TestCore::initialize(Core::NoUi);
 
   DUChain::self()->disablePersistentStorage();
   CodeRepresentation::setDiskChangesForbidden(true);
 }
 
 void TestDUChain::cleanupTestCase()
 {
   TestCore::shutdown();
 }
 
 #ifndef Q_OS_WIN
 void TestDUChain::testStringSets() {
 
   const unsigned int setCount = 8;
   const unsigned int choiceCount = 40;
   const unsigned int itemCount = 120;
 
   BasicSetRepository rep(QStringLiteral("test repository"));
 
 //  qDebug() << "Start repository-layout: \n" << rep.dumpDotGraph();
 
   qint64 repositoryTime = 0; //Time spent on repository-operations
   qint64 genericTime = 0; //Time spend on equivalent operations with generic sets
 
   qint64 repositoryIntersectionTime = 0; //Time spent on repository-operations
   qint64 genericIntersectionTime = 0; //Time spend on equivalent operations with generic sets
   qint64 qsetIntersectionTime = 0; //Time spend on equivalent operations with generic sets
 
   qint64 repositoryUnionTime = 0; //Time spent on repository-operations
   qint64 genericUnionTime = 0; //Time spend on equivalent operations with generic sets
 
   qint64 repositoryDifferenceTime = 0; //Time spent on repository-operations
   qint64 genericDifferenceTime = 0; //Time spend on equivalent operations with generic sets
 
   Set sets[setCount];
   std::set<Index> realSets[setCount];
   for(unsigned int a = 0; a < setCount; a++)
   {
     std::set<Index> chosenIndices;
     unsigned int thisCount = rand() % choiceCount;
     if(thisCount == 0)
       thisCount = 1;
 
     for(unsigned int b = 0; b < thisCount; b++)
     {
       Index choose = (rand() % itemCount) + 1;
       while(chosenIndices.find(choose) != chosenIndices.end()) {
         choose = (rand() % itemCount) + 1;
       }
 
       Timer t;
       chosenIndices.insert(chosenIndices.end(), choose);
       genericTime += t.elapsed();
     }
 
     {
       Timer t;
       sets[a] = rep.createSet(chosenIndices);
       repositoryTime += t.elapsed();
     }
 
     realSets[a] = chosenIndices;
 
     std::set<Index> tempSet = sets[a].stdSet();
 
     if(tempSet != realSets[a]) {
       QString dbg = QStringLiteral("created set: ");
       for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
         dbg += QStringLiteral("%1 ").arg(*it);
       qDebug() << dbg;
 
       dbg = QStringLiteral("repo.   set: ");
       for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
         dbg += QStringLiteral("%1 ").arg(*it);
       qDebug() << dbg;
 
       qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
       QFAIL("sets are not the same!");
     }
   }
 
   for(int cycle = 0; cycle < 100; ++cycle) {
       if(cycle % 10 == 0)
          qDebug() << "cycle" << cycle;
 
     for(unsigned int a = 0; a < setCount; a++) {
       for(unsigned int b = 0; b < setCount; b++) {
         /// ----- SUBTRACTION/DIFFERENCE
         std::set<Index> _realDifference;
         {
           Timer t;
           std::set_difference(realSets[a].begin(), realSets[a].end(), realSets[b].begin(), realSets[b].end(), std::insert_iterator<std::set<Index> >(_realDifference, _realDifference.begin()));
           genericDifferenceTime += t.elapsed();
         }
 
         Set _difference;
         {
           Timer t;
           _difference = sets[a] - sets[b];
           repositoryDifferenceTime += t.elapsed();
         }
 
         if(_difference.stdSet() != _realDifference)
         {
           {
             qDebug() << "SET a:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
           }
           {
             qDebug() << "SET b:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[b].dumpDotGraph() << "\n\n";
           }
 
           {
             std::set<Index> tempSet = _difference.stdSet();
 
             qDebug() << "SET difference:";
             QString dbg = QStringLiteral("real    set: ");
             for(std::set<Index>::const_iterator it = _realDifference.begin(); it != _realDifference.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             dbg = QStringLiteral("repo.   set: ");
             for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << _difference.dumpDotGraph() << "\n\n";
           }
           QFAIL("difference sets are not the same!");
         }
 
 
         /// ------ UNION
 
         std::set<Index> _realUnion;
         {
           Timer t;
           std::set_union(realSets[a].begin(), realSets[a].end(), realSets[b].begin(), realSets[b].end(), std::insert_iterator<std::set<Index> >(_realUnion, _realUnion.begin()));
           genericUnionTime += t.elapsed();
         }
 
         Set _union;
         {
           Timer t;
           _union = sets[a] + sets[b];
           repositoryUnionTime += t.elapsed();
         }
 
         if(_union.stdSet() != _realUnion)
         {
           {
             qDebug() << "SET a:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
           }
           {
             qDebug() << "SET b:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[b].dumpDotGraph() << "\n\n";
           }
 
           {
             std::set<Index> tempSet = _union.stdSet();
 
             qDebug() << "SET union:";
             QString dbg = QStringLiteral("real    set: ");
             for(std::set<Index>::const_iterator it = _realUnion.begin(); it != _realUnion.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             dbg = QStringLiteral("repo.   set: ");
             for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << _union.dumpDotGraph() << "\n\n";
           }
 
           QFAIL("union sets are not the same");
         }
 
         std::set<Index> _realIntersection;
 
         /// -------- INTERSECTION
         {
           Timer t;
           std::set_intersection(realSets[a].begin(), realSets[a].end(), realSets[b].begin(), realSets[b].end(), std::insert_iterator<std::set<Index> >(_realIntersection, _realIntersection.begin()));
           genericIntersectionTime += t.elapsed();
         }
 
         //Just for fun: Test how fast QSet intersections are
         QSet<Index> first, second;
         for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it) {
           first.insert(*it);
         }
         for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it) {
           second.insert(*it);
         }
         {
           Timer t;
           QSet<Index> i = first.intersect(second); // clazy:exclude=unused-non-trivial-variable
           qsetIntersectionTime += t.elapsed();
         }
 
         Set _intersection;
         {
           Timer t;
           _intersection = sets[a] & sets[b];
           repositoryIntersectionTime += t.elapsed();
         }
 
         if(_intersection.stdSet() != _realIntersection)
         {
           {
             qDebug() << "SET a:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[a].begin(); it != realSets[a].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[a].dumpDotGraph() << "\n\n";
           }
           {
             qDebug() << "SET b:";
             QString dbg;
             for(std::set<Index>::const_iterator it = realSets[b].begin(); it != realSets[b].end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << sets[b].dumpDotGraph() << "\n\n";
           }
 
           {
             std::set<Index> tempSet = _intersection.stdSet();
 
             qDebug() << "SET intersection:";
             QString dbg = QStringLiteral("real    set: ");
             for(std::set<Index>::const_iterator it = _realIntersection.begin(); it != _realIntersection.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             dbg = QStringLiteral("repo.   set: ");
             for(std::set<Index>::const_iterator it = tempSet.begin(); it != tempSet.end(); ++it)
               dbg += QStringLiteral("%1 ").arg(*it);
             qDebug() << dbg;
 
             qDebug() << "DOT-Graph:\n\n" << _intersection.dumpDotGraph() << "\n\n";
           }
           QFAIL("intersection sets are not the same");
         }
       }
     }
 
     qDebug() << "cycle " << cycle;
     qDebug() << "ns needed for set-building: repository-set: " << float(repositoryTime)
              << " generic-set: " << float(genericTime);
     qDebug() << "ns needed for intersection: repository-sets: " << float(repositoryIntersectionTime)
              << " generic-set: " << float(genericIntersectionTime) << " QSet: " << float(qsetIntersectionTime);
     qDebug() << "ns needed for union: repository-sets: " << float(repositoryUnionTime)
              << " generic-set: " << float(genericUnionTime);
     qDebug() << "ns needed for difference: repository-sets: " << float(repositoryDifferenceTime)
              << " generic-set: " << float(genericDifferenceTime);
   }
 }
 #endif
 
 void TestDUChain::testSymbolTableValid() {
   DUChainReadLocker lock(DUChain::lock());
   PersistentSymbolTable::self().dump(QTextStream(stdout));
 }
 
 void TestDUChain::testIndexedStrings() {
 
   int testCount  = 600000;
 
   QHash<QString, IndexedString> knownIndices;
   int a = 0;
   for(a = 0; a < testCount; ++a) {
     QString testString;
     int length = rand() % 10;
     for(int b = 0; b < length; ++b)
       testString.append((char)(rand() % 6) + 'a');
     QByteArray array = testString.toUtf8();
     //qDebug() << "checking with" << testString;
     //qDebug() << "checking" << a;
     IndexedString indexed(array.constData(), array.size(), IndexedString::hashString(array.constData(), array.size()));
 
     QCOMPARE(indexed.str(), testString);
     if(knownIndices.contains(testString)) {
       QCOMPARE(indexed.index(), knownIndices[testString].index());
     } else {
       knownIndices[testString] = indexed;
     }
 
     if(a % (testCount/10) == 0)
       qDebug() << a << "of" << testCount;
   }
   qDebug() << a << "successful tests";
 }
 
 struct TestContext {
   TestContext() {
     static int number = 0;
     ++number;
     DUChainWriteLocker lock(DUChain::lock());
     m_context = new TopDUContext(IndexedString(QStringLiteral("/test1/%1").arg(number)), RangeInRevision());
     m_normalContext = new DUContext(RangeInRevision(), m_context);
     DUChain::self()->addDocumentChain(m_context);
     Q_ASSERT(IndexedDUContext(m_context).context() == m_context);
   }
 
   ~TestContext() {
     foreach(TestContext* importer, importers)
       importer->unImport(QList<TestContext*>() << this);
     unImport(imports);
 
     DUChainWriteLocker lock(DUChain::lock());
     TopDUContextPointer tp(m_context);
     DUChain::self()->removeDocumentChain(static_cast<TopDUContext*>(m_context));
     Q_ASSERT(!tp);
   }
 
   void verify(QList<TestContext*> allContexts) {
 
     {
       DUChainReadLocker lock(DUChain::lock());
       QCOMPARE(m_context->importedParentContexts().count(), imports.count());
     }
     //Compute a closure of all children, and verify that they are imported.
     QSet<TestContext*> collected;
     collectImports(collected);
     collected.remove(this);
 
     DUChainReadLocker lock(DUChain::lock());
     foreach(TestContext* context, collected) {
       QVERIFY(m_context->imports(context->m_context, CursorInRevision::invalid()));
 #ifdef TEST_NORMAL_IMPORTS
       QVERIFY(m_normalContext->imports(context->m_normalContext));
 #endif
     }
     //Verify that no other contexts are imported
 
     foreach(TestContext* context, allContexts)
       if(context != this) {
         QVERIFY(collected.contains(context) || !m_context->imports(context->m_context, CursorInRevision::invalid()));
 #ifdef TEST_NORMAL_IMPORTS
         QVERIFY(collected.contains(context) || !m_normalContext->imports(context->m_normalContext, CursorInRevision::invalid()));
 #endif
       }
   }
 
   void collectImports(QSet<TestContext*>& collected) {
     if(collected.contains(this))
       return;
     collected.insert(this);
     foreach(TestContext* context, imports)
       context->collectImports(collected);
   }
   void import(TestContext* ctx) {
     if(imports.contains(ctx) || ctx == this)
       return;
     imports << ctx;
     ctx->importers << this;
     DUChainWriteLocker lock(DUChain::lock());
     m_context->addImportedParentContext(ctx->m_context);
 #ifdef TEST_NORMAL_IMPORTS
     m_normalContext->addImportedParentContext(ctx->m_normalContext);
 #endif
   }
 
   void unImport(QList<TestContext*> ctxList) {
     QList<TopDUContext*> list;
     QList<DUContext*> normalList;
 
     foreach(TestContext* ctx, ctxList) {
       if(!imports.contains(ctx))
         continue;
       list << ctx->m_context;
       normalList << ctx->m_normalContext;
 
       imports.removeAll(ctx);
       ctx->importers.removeAll(this);
     }
     DUChainWriteLocker lock(DUChain::lock());
     m_context->removeImportedParentContexts(list);
 
 #ifdef TEST_NORMAL_IMPORTS
     foreach(DUContext* ctx, normalList)
       m_normalContext->removeImportedParentContext(ctx);
 #endif
   }
 
   void clearImports() {
 
     {
       DUChainWriteLocker lock(DUChain::lock());
 
       m_context->clearImportedParentContexts();
       m_normalContext->clearImportedParentContexts();
     }
     foreach(TestContext* ctx, imports) {
       imports.removeAll(ctx);
       ctx->importers.removeAll(this);
     }
   }
 
   QList<TestContext*> imports;
 
   private:
 
   TopDUContext* m_context;
   DUContext* m_normalContext;
   QList<TestContext*> importers;
 };
 
 void collectReachableNodes(QSet<uint>& reachableNodes, uint currentNode) {
   if(!currentNode)
     return;
   reachableNodes.insert(currentNode);
   const Utils::SetNodeData* node = KDevelop::RecursiveImportRepository::repository()->nodeFromIndex(currentNode);
   Q_ASSERT(node);
   collectReachableNodes(reachableNodes, node->leftNode());
   collectReachableNodes(reachableNodes, node->rightNode());
 }
 
 uint collectNaiveNodeCount(uint currentNode) {
   if(!currentNode)
     return 0;
   uint ret = 1;
   const Utils::SetNodeData* node = KDevelop::RecursiveImportRepository::repository()->nodeFromIndex(currentNode);
   Q_ASSERT(node);
   ret += collectNaiveNodeCount(node->leftNode());
   ret += collectNaiveNodeCount(node->rightNode());
   return ret;
 }
 
 void TestDUChain::testImportStructure()
 {
   Timer total;
-  qDebug() << "before: " << KDevelop::RecursiveImportRepository::repository()->getDataRepository().statistics().print();
+  qDebug() << "before: " << KDevelop::RecursiveImportRepository::repository()->dataRepository().statistics().print();
 
   ///Maintains a naive import-structure along with a real top-context import structure, and allows comparing both.
   int cycles = 5;
   //int cycles = 100;
   //srand(time(NULL));
   for(int t = 0; t < cycles; ++t) {
     QList<TestContext*> allContexts;
     //Create a random structure
     int contextCount = 50;
     int verifyOnceIn = contextCount/*((contextCount*contextCount)/20)+1*/; //Verify once in every chances(not in all cases, because else the import-structure isn't built on-demand!)
     int clearOnceIn = contextCount;
     for(int a = 0; a < contextCount; a++)
       allContexts << new TestContext();
     for(int c = 0; c < cycles; ++c) {
       //qDebug() << "main-cycle" << t  << "sub-cycle" << c;
       //Add random imports and compare
       for(int a = 0; a < contextCount; a++) {
         //Import up to 5 random other contexts into each context
         int importCount = rand() % 5;
         //qDebug()   << "cnt> " << importCount;
         for(int i = 0; i < importCount; ++i)
         {
           //int importNr = rand() % contextCount;
           //qDebug() << "nmr > " << importNr;
           //allContexts[a]->import(allContexts[importNr]);
           allContexts[a]->import(allContexts[rand() % contextCount]);
         }
         for(int b = 0; b < contextCount; b++)
           if(rand() % verifyOnceIn == 0)
             allContexts[b]->verify(allContexts);
       }
 
       //Remove random imports and compare
       for(int a = 0; a < contextCount; a++) {
         //Import up to 5 random other contexts into each context
         int removeCount = rand() % 3;
         QSet<TestContext*> removeImports;
         for(int i = 0; i < removeCount; ++i)
           if(!allContexts[a]->imports.isEmpty())
             removeImports.insert(allContexts[a]->imports[rand() % allContexts[a]->imports.count()]);
         allContexts[a]->unImport(removeImports.toList());
 
         for(int b = 0; b < contextCount; b++)
           if(rand() % verifyOnceIn == 0)
             allContexts[b]->verify(allContexts);
       }
 
       for(int a = 0; a < contextCount; a++) {
         if(rand() % clearOnceIn == 0) {
           allContexts[a]->clearImports();
           allContexts[a]->verify(allContexts);
         }
       }
     }
 
-    qDebug() << "after: " << KDevelop::RecursiveImportRepository::repository()->getDataRepository().statistics().print();
+    qDebug() << "after: " << KDevelop::RecursiveImportRepository::repository()->dataRepository().statistics().print();
 
     for(int a = 0; a < contextCount; ++a)
       delete allContexts[a];
     allContexts.clear();
-    qDebug() << "after cleanup: " << KDevelop::RecursiveImportRepository::repository()->getDataRepository().statistics().print();
+    qDebug() << "after cleanup: " << KDevelop::RecursiveImportRepository::repository()->dataRepository().statistics().print();
   }
   qDebug() << "total ns needed for import-structure test:" << float(total.elapsed());
 }
 
 class TestWorker : public QObject
 {
   Q_OBJECT
 public Q_SLOTS:
   void lockForWrite()
   {
     for(int i = 0; i < 10000; ++i) {
       DUChainWriteLocker lock;
     }
   }
   void lockForRead()
   {
     for(int i = 0; i < 10000; ++i) {
       DUChainReadLocker lock;
     }
   }
   void lockForReadWrite()
   {
     for(int i = 0; i < 10000; ++i) {
       {
         DUChainReadLocker lock;
       }
       {
         DUChainWriteLocker lock;
       }
     }
   }
   static QSharedPointer<QThread> createWorkerThread(const char* workerSlot)
   {
     QThread* thread = new QThread;
     TestWorker* worker = new TestWorker;
     connect(thread, SIGNAL(started()), worker, workerSlot);
     connect(thread, &QThread::finished, worker, &TestWorker::deleteLater);
     worker->moveToThread(thread);
     return QSharedPointer<QThread>(thread);
   }
 };
 
 class ThreadList : public QVector< QSharedPointer<QThread> >
 {
 public:
   bool join(int timeout)
   {
     foreach(const QSharedPointer<QThread>& thread, *this) {
       // quit event loop
       Q_ASSERT(thread->isRunning());
       thread->quit();
       // wait for finish
       if (!thread->wait(timeout)) {
         return false;
       }
       Q_ASSERT(thread->isFinished());
     }
     return true;
   }
   void start()
   {
     foreach(const QSharedPointer<QThread>& thread, *this) {
       thread->start();
     }
   }
 };
 
 void TestDUChain::testLockForWrite()
 {
   ThreadList threads;
   for(int i = 0; i < 10; ++i) {
     threads << TestWorker::createWorkerThread(SLOT(lockForWrite()));
   }
   threads.start();
   QBENCHMARK {
     {
       DUChainWriteLocker lock;
     }
     {
       DUChainReadLocker lock;
     }
   }
   QVERIFY(threads.join(1000));
 }
 
 void TestDUChain::testLockForRead()
 {
   ThreadList threads;
   for(int i = 0; i < 10; ++i) {
     threads << TestWorker::createWorkerThread(SLOT(lockForRead()));
   }
   threads.start();
   QBENCHMARK {
     DUChainReadLocker lock;
   }
   QVERIFY(threads.join(1000));
 }
 
 void TestDUChain::testLockForReadWrite()
 {
   ThreadList threads;
   for(int i = 0; i < 10; ++i) {
     threads << TestWorker::createWorkerThread(SLOT(lockForReadWrite()));
   }
   threads.start();
   QBENCHMARK {
     DUChainWriteLocker lock;
   }
   QVERIFY(threads.join(1000));
 }
 
 void TestDUChain::testProblemSerialization()
 {
   DUChain::self()->disablePersistentStorage(false);
 
   auto parent = ProblemPointer{new Problem};
   parent->setDescription(QStringLiteral("parent"));
 
   auto child = ProblemPointer{new Problem};
   child->setDescription(QStringLiteral("child"));
   parent->addDiagnostic(child);
 
   const IndexedString url("/my/test/file");
 
   TopDUContextPointer smartTop;
 
   { // serialize
     DUChainWriteLocker lock;
     auto file = new ParsingEnvironmentFile(url);
     auto top = new TopDUContext(url, {}, file);
 
     top->addProblem(parent);
     QCOMPARE(top->problems().size(), 1);
     auto p = top->problems().at(0);
     QCOMPARE(p->description(), QStringLiteral("parent"));
     QCOMPARE(p->diagnostics().size(), 1);
     auto c = p->diagnostics().first();
     QCOMPARE(c->description(), QStringLiteral("child"));
 
     DUChain::self()->addDocumentChain(top);
     QVERIFY(DUChain::self()->chainForDocument(url));
     smartTop = top;
   }
 
   DUChain::self()->storeToDisk();
 
   ProblemPointer parent_deserialized;
   IProblem::Ptr child_deserialized;
 
   { // deserialize
     DUChainWriteLocker lock;
     QVERIFY(!smartTop);
     auto top = DUChain::self()->chainForDocument(url);
     QVERIFY(top);
     smartTop = top;
     QCOMPARE(top->problems().size(), 1);
     parent_deserialized = top->problems().at(0);
     QCOMPARE(parent_deserialized->diagnostics().size(), 1);
     child_deserialized = parent_deserialized->diagnostics().first();
 
     QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
     QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
     top->clearProblems();
     QVERIFY(top->problems().isEmpty());
 
     QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
     QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
     DUChain::self()->removeDocumentChain(top);
 
     QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
     QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
     QVERIFY(!smartTop);
   }
 
   DUChain::self()->disablePersistentStorage(true);
 
   QCOMPARE(parent->description(), QStringLiteral("parent"));
   QCOMPARE(child->description(), QStringLiteral("child"));
   QCOMPARE(parent_deserialized->description(), QStringLiteral("parent"));
   QCOMPARE(child_deserialized->description(), QStringLiteral("child"));
 
   parent->clearDiagnostics();
   QVERIFY(parent->diagnostics().isEmpty());
 }
 
 void TestDUChain::testIdentifiers()
 {
   QualifiedIdentifier aj(QStringLiteral("::Area::jump"));
   QCOMPARE(aj.count(), 2);
   QCOMPARE(aj.explicitlyGlobal(), true);
   QCOMPARE(aj.at(0), Identifier(QStringLiteral("Area")));
   QCOMPARE(aj.at(1), Identifier(QStringLiteral("jump")));
 
   QualifiedIdentifier aj2 = QualifiedIdentifier(QStringLiteral("Area::jump"));
   QCOMPARE(aj2.count(), 2);
   QCOMPARE(aj2.explicitlyGlobal(), false);
   QCOMPARE(aj2.at(0), Identifier(QStringLiteral("Area")));
   QCOMPARE(aj2.at(1), Identifier(QStringLiteral("jump")));
   QVERIFY(aj != aj2);
 
   QVERIFY(QualifiedIdentifier(QString()) == QualifiedIdentifier());
   QVERIFY(QualifiedIdentifier(QString()).index() == QualifiedIdentifier().index());
 
   QualifiedIdentifier ajt(QStringLiteral("Area::jump::test"));
   QualifiedIdentifier jt(QStringLiteral("jump::test"));
   QualifiedIdentifier ajt2(QStringLiteral("Area::jump::tes"));
 
   QualifiedIdentifier t(QStringLiteral(" Area<A,B>::jump <F> ::tes<C>"));
   QCOMPARE(t.count(), 3);
   QCOMPARE(t.at(0).templateIdentifiersCount(), 2u);
   QCOMPARE(t.at(1).templateIdentifiersCount(), 1u);
   QCOMPARE(t.at(2).templateIdentifiersCount(), 1u);
   QCOMPARE(t.at(0).identifier().str(), QStringLiteral("Area"));
   QCOMPARE(t.at(1).identifier().str(), QStringLiteral("jump"));
   QCOMPARE(t.at(2).identifier().str(), QStringLiteral("tes"));
 
   QualifiedIdentifier op1(QStringLiteral("operator<"));
   QualifiedIdentifier op2(QStringLiteral("operator<="));
   QualifiedIdentifier op3(QStringLiteral("operator>"));
   QualifiedIdentifier op4(QStringLiteral("operator>="));
   QualifiedIdentifier op5(QStringLiteral("operator()"));
   QualifiedIdentifier op6(QStringLiteral("operator( )"));
   QCOMPARE(op1.count(), 1);
   QCOMPARE(op2.count(), 1);
   QCOMPARE(op3.count(), 1);
   QCOMPARE(op4.count(), 1);
   QCOMPARE(op5.count(), 1);
   QCOMPARE(op6.count(), 1);
   QCOMPARE(op4.toString(), QStringLiteral("operator>="));
   QCOMPARE(op3.toString(), QStringLiteral("operator>"));
   QCOMPARE(op1.toString(), QStringLiteral("operator<"));
   QCOMPARE(op2.toString(), QStringLiteral("operator<="));
   QCOMPARE(op5.toString(), QStringLiteral("operator()"));
   QCOMPARE(op6.toString(), QStringLiteral("operator( )"));
   QCOMPARE(QualifiedIdentifier(QStringLiteral("Area<A,B>::jump <F> ::tes<C>")).index(), t.index());
   QCOMPARE(op4.index(), QualifiedIdentifier(QStringLiteral("operator>=")).index());
 
   QualifiedIdentifier pushTest(QStringLiteral("foo"));
   QCOMPARE(pushTest.count(), 1);
   QCOMPARE(pushTest.toString(), QStringLiteral("foo"));
   pushTest.push(Identifier(QStringLiteral("bar")));
   QCOMPARE(pushTest.count(), 2);
   QCOMPARE(pushTest.toString(), QStringLiteral("foo::bar"));
   pushTest.push(QualifiedIdentifier(QStringLiteral("baz::asdf")));
   QCOMPARE(pushTest.count(), 4);
   QCOMPARE(pushTest.toString(), QStringLiteral("foo::bar::baz::asdf"));
   QualifiedIdentifier mergeTest = pushTest.merge(QualifiedIdentifier(QStringLiteral("meh::muh")));
   QCOMPARE(mergeTest.count(), 6);
   QCOMPARE(mergeTest.toString(), QStringLiteral("meh::muh::foo::bar::baz::asdf"));
   QualifiedIdentifier plusTest = QualifiedIdentifier(QStringLiteral("la::lu")) + QualifiedIdentifier(QStringLiteral("ba::bu"));
   QCOMPARE(plusTest.count(), 4);
   QCOMPARE(plusTest.toString(), QStringLiteral("la::lu::ba::bu"));
   ///@todo create a big randomized test for the identifier repository(check that indices are the same)
 }
 
 #if 0
 
 ///NOTE: the "unit tests" below are not automated, they - so far - require
 ///      human interpretation which is not useful for a unit test!
 ///      someone should investigate what the expected output should be
 ///      and add proper QCOMPARE/QVERIFY checks accordingly
 
 ///FIXME: this needs to be rewritten in order to remove dependencies on formerly run unit tests
 void TestDUChain::testImportCache()
 {
   KDevelop::globalItemRepositoryRegistry().printAllStatistics();
 
   KDevelop::RecursiveImportRepository::repository()->printStatistics();
 
   //Analyze the whole existing import-cache
   //This is very expensive, since it involves loading all existing top-contexts
   uint topContextCount = DUChain::self()->newTopContextIndex();
 
   uint analyzedCount = 0;
   uint totalImportCount = 0;
   uint naiveNodeCount = 0;
   QSet<uint> reachableNodes;
 
   DUChainReadLocker lock(DUChain::lock());
   for(uint a = 0; a < topContextCount; ++a) {
     if(a % qMax(1u, topContextCount / 100) == 0) {
       qDebug() << "progress:" << (a * 100) / topContextCount;
     }
     TopDUContext* context = DUChain::self()->chainForIndex(a);
     if(context) {
       TopDUContext::IndexedRecursiveImports imports = context->recursiveImportIndices();
       ++analyzedCount;
       totalImportCount += imports.set().count();
       collectReachableNodes(reachableNodes, imports.setIndex());
       naiveNodeCount += collectNaiveNodeCount(imports.setIndex());
     }
   }
 
   QVERIFY(analyzedCount);
   qDebug() << "average total count of imports:" << totalImportCount / analyzedCount;
   qDebug() << "count of reachable nodes:" << reachableNodes.size();
   qDebug() << "naive node-count:" << naiveNodeCount << "sharing compression factor:" << ((float)reachableNodes.size()) / ((float)naiveNodeCount);
 }
 
 #endif
 
 void TestDUChain::benchCodeModel()
 {
   const IndexedString file("testFile");
 
   QVERIFY(!QTypeInfo< KDevelop::CodeModelItem >::isStatic);
 
   int i = 0;
   QBENCHMARK {
     CodeModel::self().addItem(file, QualifiedIdentifier("testQID" + QString::number(i++)),
                               KDevelop::CodeModelItem::Class);
   }
 }
 
 void TestDUChain::benchTypeRegistry()
 {
   IntegralTypeData data;
   data.m_dataType = IntegralType::TypeInt;
   data.typeClassId = IntegralType::Identity;
   data.inRepository = false;
   data.m_modifiers = 42;
   data.m_dynamic = false;
   data.refCount = 1;
 
   IntegralTypeData to;
 
   QFETCH(int, func);
 
   QBENCHMARK {
     switch(func) {
       case 0:
         TypeSystem::self().dataClassSize(data);
         break;
       case 1:
         TypeSystem::self().dynamicSize(data);
         break;
       case 2:
         TypeSystem::self().create(&data);
         break;
       case 3:
         TypeSystem::self().isFactoryLoaded(data);
         break;
       case 4:
         TypeSystem::self().copy(data, to, !data.m_dynamic);
         break;
       case 5:
         TypeSystem::self().copy(data, to, data.m_dynamic);
         break;
       case 6:
         TypeSystem::self().callDestructor(&data);
         break;
     }
   }
 }
 
 void TestDUChain::benchTypeRegistry_data()
 {
   QTest::addColumn<int>("func");
   QTest::newRow("dataClassSize") << 0;
   QTest::newRow("dynamicSize") << 1;
   QTest::newRow("create") << 2;
   QTest::newRow("isFactoryLoaded") << 3;
   QTest::newRow("copy") << 4;
   QTest::newRow("copyNonDynamic") << 5;
   QTest::newRow("callDestructor") << 6;
 }
 
 void TestDUChain::benchDuchainReadLocker()
 {
   QBENCHMARK {
     DUChainReadLocker lock;
   }
 }
 
 void TestDUChain::benchDuchainWriteLocker()
 {
   QBENCHMARK {
     DUChainWriteLocker lock;
   }
 }
 
 void TestDUChain::benchDUChainItemFactory_copy()
 {
   DUChainItemFactory<Declaration, DeclarationData> factory;
   DeclarationData from, to;
   from.classId = Declaration::Identity;
 
   QFETCH(int, constant);
 
   bool c = constant;
 
   QBENCHMARK {
     factory.copy(from, to, c);
     if (constant == 2) {
       c = !c;
     }
   }
 }
 
 void TestDUChain::benchDUChainItemFactory_copy_data()
 {
   QTest::addColumn<int>("constant");
   QTest::newRow("non-const") << 0;
   QTest::newRow("const") << 1;
   QTest::newRow("flip") << 2;
 }
 
 void TestDUChain::benchDeclarationQualifiedIdentifier()
 {
   QVector<DUContext*> contexts;
   contexts.reserve(10);
   DUChainWriteLocker lock;
   contexts << new TopDUContext(IndexedString("/tmp/something"), {0, 0, INT_MAX, INT_MAX});
   for (int i = 1; i < contexts.capacity(); ++i) {
     contexts << new DUContext({0, 0, INT_MAX, INT_MAX}, contexts.at(i-1));
     contexts.last()->setLocalScopeIdentifier(QualifiedIdentifier(QString::number(i)));
   }
   auto dec = new Declaration({0, 0, 0, 1}, contexts.last());
   dec->setIdentifier(Identifier(QStringLiteral("myDecl")));
 
   qDebug() << "start benchmark!";
   qint64 count = 0;
   QBENCHMARK {
     count += dec->qualifiedIdentifier().count();
   }
   QVERIFY(count > 0);
 }
 
 #include "test_duchain.moc"
 #include "moc_test_duchain.cpp"
diff --git a/kdevplatform/language/duchain/topducontext.cpp b/kdevplatform/language/duchain/topducontext.cpp
index 054a6b4a38..a72d6b4ce9 100644
--- a/kdevplatform/language/duchain/topducontext.cpp
+++ b/kdevplatform/language/duchain/topducontext.cpp
@@ -1,1161 +1,1161 @@
 /* This  is part of KDevelop
     Copyright 2006 Hamish Rodda <rodda@kde.org>
     Copyright 2007-2009 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 "topducontext.h"
 #include "topducontextutils.h"
 
 #include <limits>
 
 #include "persistentsymboltable.h"
 #include "problem.h"
 #include "declaration.h"
 #include "duchain.h"
 #include "duchainlock.h"
 #include "parsingenvironment.h"
 #include "duchainpointer.h"
 #include "declarationid.h"
 #include "namespacealiasdeclaration.h"
 #include "aliasdeclaration.h"
 #include "uses.h"
 #include "topducontextdata.h"
 #include "duchainregister.h"
 #include "topducontextdynamicdata.h"
 #include <debug.h>
 
 #include <language/interfaces/iastcontainer.h>
 
 // #define DEBUG_SEARCH
 
 const uint maxApplyAliasesRecursion = 100;
 
 namespace KDevelop
 {
 
 Utils::BasicSetRepository* RecursiveImportRepository::repository() {
   static Utils::BasicSetRepository recursiveImportRepositoryObject(QStringLiteral("Recursive Imports"), &KDevelop::globalItemRepositoryRegistry());
   return &recursiveImportRepositoryObject;
 }
 
 ReferencedTopDUContext::ReferencedTopDUContext(TopDUContext* context) : m_topContext(context) {
   if(m_topContext)
     DUChain::self()->refCountUp(m_topContext);
 }
 
 ReferencedTopDUContext::ReferencedTopDUContext(const ReferencedTopDUContext& rhs) : m_topContext(rhs.m_topContext) {
   if(m_topContext)
     DUChain::self()->refCountUp(m_topContext);
 }
 
 ReferencedTopDUContext::~ReferencedTopDUContext() {
   if(m_topContext && !DUChain::deleted())
     DUChain::self()->refCountDown(m_topContext);
 }
 
 ReferencedTopDUContext& ReferencedTopDUContext::operator=(const ReferencedTopDUContext& rhs) {
   if(m_topContext == rhs.m_topContext)
     return *this;
 
   if(m_topContext)
     DUChain::self()->refCountDown(m_topContext);
 
   m_topContext = rhs.m_topContext;
 
   if(m_topContext)
     DUChain::self()->refCountUp(m_topContext);
   return *this;
 }
 
 DEFINE_LIST_MEMBER_HASH(TopDUContextData, m_usedDeclarationIds, DeclarationId)
 DEFINE_LIST_MEMBER_HASH(TopDUContextData, m_problems, LocalIndexedProblem)
 REGISTER_DUCHAIN_ITEM(TopDUContext);
 
 QMutex importStructureMutex(QMutex::Recursive);
 
 //Contains data that is not shared among top-contexts that share their duchain entries
 class TopDUContextLocalPrivate {
 public:
   TopDUContextLocalPrivate (TopDUContext* ctxt, uint index) :
     m_ctxt(ctxt), m_ownIndex(index), m_inDuChain(false)
   {
     m_indexedRecursiveImports.insert(index);
   }
 
   ~TopDUContextLocalPrivate() {
     //Either we use some other contexts data and have no users, or we own the data and have users that share it.
     QMutexLocker lock(&importStructureMutex);
 
     foreach(const DUContext::Import& import, m_importedContexts)
       if(DUChain::self()->isInMemory(import.topContextIndex()) && dynamic_cast<TopDUContext*>(import.context(nullptr)))
         dynamic_cast<TopDUContext*>(import.context(nullptr))->m_local->m_directImporters.remove(m_ctxt);
   }
 
   ///@todo Make all this work consistently together with import-caching
 
   //After loading, should rebuild the links
   void rebuildDynamicImportStructure() {
     //Currently we do not store the whole data in TopDUContextLocalPrivate, so we reconstruct it from what was stored by DUContext.
     Q_ASSERT(m_importedContexts.isEmpty());
 
     FOREACH_FUNCTION(const DUContext::Import& import, m_ctxt->d_func()->m_importedContexts) {
       if(DUChain::self()->isInMemory(import.topContextIndex())) {
         Q_ASSERT(import.context(nullptr));
         TopDUContext* top = import.context(nullptr)->topContext();
         Q_ASSERT(top);
         addImportedContextRecursively(top, false, true);
       }
     }
     FOREACH_FUNCTION(const IndexedDUContext& importer, m_ctxt->d_func()->m_importers) {
       if(DUChain::self()->isInMemory(importer.topContextIndex())) {
         Q_ASSERT(importer.context());
         TopDUContext* top = importer.context()->topContext();
         Q_ASSERT(top);
         top->m_local->addImportedContextRecursively(m_ctxt, false, true);
       }
     }
   }
 
   //Index of this top-context within the duchain
   //Since the data of top-contexts can be shared among multiple, this can be used to add imports that are local to this top-context.
   QVector<DUContext::Import> m_importedContexts;
 //   mutable bool m_haveImportStructure : 1;
   TopDUContext* m_ctxt;
 
   QSet<DUContext*> m_directImporters;
 
   ParsingEnvironmentFilePointer m_file;
 
   QExplicitlySharedDataPointer<IAstContainer> m_ast;
 
   uint m_ownIndex;
 
   bool m_inDuChain;
 
 
   void clearImportedContextsRecursively() {
     QMutexLocker lock(&importStructureMutex);
 
 //     Q_ASSERT(m_recursiveImports.size() == m_indexedRecursiveImports.count()-1);
 
     QSet<QPair<TopDUContext*, const TopDUContext*> > rebuild;
 
     foreach(const DUContext::Import &import, m_importedContexts) {
       TopDUContext* top = dynamic_cast<TopDUContext*>(import.context(nullptr));
       if(top) {
         top->m_local->m_directImporters.remove(m_ctxt);
 
         if(!m_ctxt->usingImportsCache()) {
           removeImportedContextRecursion(top, top, 1, rebuild);
 
           QHash<const TopDUContext*, QPair<int, const TopDUContext*> > b = top->m_local->m_recursiveImports;
           for(RecursiveImports::const_iterator it = b.constBegin(); it != b.constEnd(); ++it) {
             if(m_recursiveImports.contains(it.key()) && m_recursiveImports[it.key()].second == top)
               removeImportedContextRecursion(top, it.key(), it->first+1, rebuild); //Remove all contexts that are imported through the context
           }
         }
       }
     }
 
     m_importedContexts.clear();
 
     rebuildImportStructureRecursion(rebuild);
 
     Q_ASSERT(m_recursiveImports.isEmpty());
 //     Q_ASSERT(m_recursiveImports.size() == m_indexedRecursiveImports.count()-1);
   }
 
   //Adds the context to this and all contexts that import this, and manages m_recursiveImports
   void addImportedContextRecursively(TopDUContext* context, bool temporary, bool local) {
     QMutexLocker lock(&importStructureMutex);
 
     context->m_local->m_directImporters.insert(m_ctxt);
 
     if(local) {
       // note: m_importedContexts may end up with duplicate entries -- not sure whether we should protect against this --Kevin
       m_importedContexts << DUContext::Import(context, m_ctxt);
     }
 
     if(!m_ctxt->usingImportsCache()) {
       addImportedContextRecursion(context, context, 1, temporary);
 
       QHash<const TopDUContext*, QPair<int, const TopDUContext*> > b = context->m_local->m_recursiveImports;
       for(RecursiveImports::const_iterator it = b.constBegin(); it != b.constEnd(); ++it)
         addImportedContextRecursion(context, it.key(), (*it).first+1, temporary); //Add contexts that were imported earlier into the given one
     }
   }
 
   //Removes the context from this and all contexts that import this, and manages m_recursiveImports
   void removeImportedContextRecursively(TopDUContext* context, bool local) {
     QMutexLocker lock(&importStructureMutex);
 
     context->m_local->m_directImporters.remove(m_ctxt);
 
     if(local)
       m_importedContexts.removeAll(DUContext::Import(context, m_ctxt));
 
     QSet<QPair<TopDUContext*, const TopDUContext*> > rebuild;
     if(!m_ctxt->usingImportsCache()) {
 
     removeImportedContextRecursion(context, context, 1, rebuild);
 
       QHash<const TopDUContext*, QPair<int, const TopDUContext*> > b = context->m_local->m_recursiveImports;
       for(RecursiveImports::const_iterator it = b.constBegin(); it != b.constEnd(); ++it) {
         if(m_recursiveImports.contains(it.key()) && m_recursiveImports[it.key()].second == context)
           removeImportedContextRecursion(context, it.key(), it->first+1, rebuild); //Remove all contexts that are imported through the context
       }
     }
 
     rebuildImportStructureRecursion(rebuild);
   }
 
   void removeImportedContextsRecursively(const QList<TopDUContext*>& contexts, bool local) {
     QMutexLocker lock(&importStructureMutex);
 
 
     QSet<QPair<TopDUContext*, const TopDUContext*> > rebuild;
     for (TopDUContext* context : contexts) {
 
       context->m_local->m_directImporters.remove(m_ctxt);
 
       if(local)
         m_importedContexts.removeAll(DUContext::Import(context, m_ctxt));
 
       if(!m_ctxt->usingImportsCache()) {
 
         removeImportedContextRecursion(context, context, 1, rebuild);
 
         QHash<const TopDUContext*, QPair<int, const TopDUContext*> > b = context->m_local->m_recursiveImports;
         for(RecursiveImports::const_iterator it = b.constBegin(); it != b.constEnd(); ++it) {
           if(m_recursiveImports.contains(it.key()) && m_recursiveImports[it.key()].second == context)
             removeImportedContextRecursion(context, it.key(), it->first+1, rebuild); //Remove all contexts that are imported through the context
         }
       }
     }
 
     rebuildImportStructureRecursion(rebuild);
   }
 
   //Has an entry for every single recursively imported file, that contains the shortest path, and the next context on that path to the imported context.
   //This does not need to be stored to disk, because it is defined implicitly.
   //What makes this most complicated is the fact that loops are allowed in the import structure.
   typedef QHash<const TopDUContext*, QPair<int, const TopDUContext*> > RecursiveImports;
   mutable RecursiveImports m_recursiveImports;
   mutable TopDUContext::IndexedRecursiveImports m_indexedRecursiveImports;
   private:
   void addImportedContextRecursion(const TopDUContext* traceNext, const TopDUContext* imported, int depth, bool temporary = false) {
 
     if(m_ctxt->usingImportsCache())
       return;
 
 //     if(!m_haveImportStructure)
 //       return;
 
     if(imported == m_ctxt)
       return;
 
     const bool computeShortestPaths = false;  ///@todo We do not compute the shortest path. Think what's right.
 
 //     traceNext->m_local->needImportStructure();
 //     imported->m_local->needImportStructure();
 
     RecursiveImports::iterator it = m_recursiveImports.find(imported);
     if(it == m_recursiveImports.end()) {
       //Insert new path to "imported"
       m_recursiveImports[imported] = qMakePair(depth, traceNext);
 
       m_indexedRecursiveImports.insert(imported->indexed());
 //       Q_ASSERT(m_indexedRecursiveImports.size() == m_recursiveImports.size()+1);
 
       Q_ASSERT(traceNext != m_ctxt);
     }else{
       if(!computeShortestPaths)
         return;
 
       if(temporary) //For temporary imports, we don't record the best path.
         return;
       //It would be better if we would use the following code, but it creates too much cost in updateImportedContextRecursion when imports are removed again.
 
       //Check whether the new way to "imported" is shorter than the stored one
       if((*it).first > depth) {
         //Add a shorter path
         (*it).first = depth;
         Q_ASSERT(traceNext);
         (*it).second = traceNext;
         Q_ASSERT(traceNext == imported || (traceNext->m_local->m_recursiveImports.contains(imported) && traceNext->m_local->m_recursiveImports[imported].first < (*it).first));
       }else{
         //The imported context is already imported through a same/better path, so we can just stop processing. This saves us from endless recursion.
         return;
       }
     }
 
     if(temporary)
       return;
 
     for(QSet<DUContext*>::const_iterator it = m_directImporters.constBegin(); it != m_directImporters.constEnd(); ++it) {
       TopDUContext* top = dynamic_cast<TopDUContext*>(const_cast<DUContext*>(*it)); //Avoid detaching, so use const_cast
       if(top) ///@todo also record this for local imports
         top->m_local->addImportedContextRecursion(m_ctxt, imported, depth+1);
     }
   }
 
   void removeImportedContextRecursion(const TopDUContext* traceNext, const TopDUContext* imported, int distance, QSet<QPair<TopDUContext*, const TopDUContext*> >& rebuild) {
 
     if(m_ctxt->usingImportsCache())
        return;
 
     if(imported == m_ctxt)
       return;
 
 //     if(!m_haveImportStructure)
 //       return;
 
     RecursiveImports::iterator it = m_recursiveImports.find(imported);
     if(it == m_recursiveImports.end()) {
       //We don't import. Just return, this saves us from endless recursion.
       return;
     }else{
       //Check whether we have imported "imported" through "traceNext". If not, return. Else find a new trace.
       if((*it).second == traceNext && (*it).first == distance) {
         //We need to remove the import through traceNext. Check whether there is another imported context that imports it.
 
         m_recursiveImports.erase(it); //In order to prevent problems, we completely remove everything, and re-add it.
                                       //Just updating these complex structures is very hard.
                                       Q_ASSERT(imported != m_ctxt);
 
         m_indexedRecursiveImports.remove(imported->indexed());
 //         Q_ASSERT(m_indexedRecursiveImports.size() == m_recursiveImports.size());
 
         rebuild.insert(qMakePair(m_ctxt, imported));
         //We MUST do this before finding another trace, because else we would create loops
         for(QSet<DUContext*>::const_iterator childIt = m_directImporters.constBegin(); childIt != m_directImporters.constEnd(); ++childIt) {
           TopDUContext* top = dynamic_cast<TopDUContext*>(const_cast<DUContext*>(*childIt)); //Avoid detaching, so use const iterator
           if(top)
             top->m_local->removeImportedContextRecursion(m_ctxt, imported, distance+1, rebuild); //Don't use 'it' from here on, it may be invalid
         }
       }
     }
   }
 
   //Updates the trace to 'imported'
   void rebuildStructure(const TopDUContext* imported);
 
   void rebuildImportStructureRecursion(const QSet<QPair<TopDUContext*, const TopDUContext*> >& rebuild) {
     for(QSet<QPair<TopDUContext*, const TopDUContext*> >::const_iterator it = rebuild.constBegin(); it != rebuild.constEnd(); ++it) {
     //for(int a = rebuild.size()-1; a >= 0; --a) {
       //Find the best imported parent
       it->first->m_local->rebuildStructure(it->second);
     }
   }
 };
 
 const TopDUContext::IndexedRecursiveImports& TopDUContext::recursiveImportIndices() const
 {
 //   No lock-check for performance reasons
   QMutexLocker lock(&importStructureMutex);
   if(!d_func()->m_importsCache.isEmpty())
     return d_func()->m_importsCache;
 
   return m_local->m_indexedRecursiveImports;
 }
 
 void TopDUContextData::updateImportCacheRecursion(uint baseIndex, IndexedTopDUContext currentContext, TopDUContext::IndexedRecursiveImports& visited) {
   if(visited.contains(currentContext.index()))
     return;
   Q_ASSERT(currentContext.index()); //The top-context must be in the repository when this is called
   if(!currentContext.data()) {
     qCDebug(LANGUAGE) << "importing invalid context";
     return;
   }
   visited.insert(currentContext.index());
 
   const TopDUContextData* currentData = currentContext.data()->topContext()->d_func();
   if(currentData->m_importsCache.contains(baseIndex) || currentData->m_importsCache.isEmpty())
   {
     //If we have a loop or no imports-cache is used, we have to look at each import separately.
     const KDevelop::DUContext::Import* imports = currentData->m_importedContexts();
     uint importsSize = currentData->m_importedContextsSize();
     for(uint a = 0; a < importsSize; ++a) {
       IndexedTopDUContext next(imports[a].topContextIndex());
       if(next.isValid())
         updateImportCacheRecursion(baseIndex, next, visited);
     }
   }else{
     //If we don't have a loop with baseIndex, we can safely just merge with the imported importscache
     visited += currentData->m_importsCache;
   }
 }
 
 void TopDUContextData::updateImportCacheRecursion(IndexedTopDUContext currentContext, std::set<uint>& visited) {
   if(visited.find(currentContext.index()) != visited.end())
     return;
   Q_ASSERT(currentContext.index()); //The top-context must be in the repository when this is called
   if(!currentContext.data()) {
     qCDebug(LANGUAGE) << "importing invalid context";
     return;
   }
   visited.insert(currentContext.index());
   const TopDUContextData* currentData = currentContext.data()->topContext()->d_func();
   const KDevelop::DUContext::Import* imports = currentData->m_importedContexts();
   uint importsSize = currentData->m_importedContextsSize();
   for(uint a = 0; a < importsSize; ++a) {
     IndexedTopDUContext next(imports[a].topContextIndex());
     if(next.isValid())
       updateImportCacheRecursion(next, visited);
   }
 }
 
 
 
 void TopDUContext::updateImportsCache() {
   QMutexLocker lock(&importStructureMutex);
 
 
   const bool use_fully_recursive_import_cache_computation = false;
 
   if(use_fully_recursive_import_cache_computation) {
     std::set<uint> visited;
     TopDUContextData::updateImportCacheRecursion(this, visited);
     Q_ASSERT(visited.find(ownIndex()) != visited.end());
     d_func_dynamic()->m_importsCache = IndexedRecursiveImports(visited);
   }else{
     d_func_dynamic()->m_importsCache = IndexedRecursiveImports();
     TopDUContextData::updateImportCacheRecursion(ownIndex(), this, d_func_dynamic()->m_importsCache);
   }
   Q_ASSERT(d_func_dynamic()->m_importsCache.contains(IndexedTopDUContext(this)));
   Q_ASSERT(usingImportsCache());
   Q_ASSERT(imports(this, CursorInRevision::invalid()));
 
   if(parsingEnvironmentFile())
     parsingEnvironmentFile()->setImportsCache(d_func()->m_importsCache);
 }
 
 bool TopDUContext::usingImportsCache() const {
   return !d_func()->m_importsCache.isEmpty();
 }
 
 CursorInRevision TopDUContext::importPosition(const DUContext* target) const
 {
   ENSURE_CAN_READ
   DUCHAIN_D(DUContext);
   Import import(const_cast<DUContext*>(target), const_cast<TopDUContext*>(this), CursorInRevision::invalid());
   for(unsigned int a = 0; a < d->m_importedContextsSize(); ++a)
     if(d->m_importedContexts()[a] == import)
       return d->m_importedContexts()[a].position;
 
   return DUContext::importPosition(target);
 }
 
 
 void TopDUContextLocalPrivate::rebuildStructure(const TopDUContext* imported) {
   if(m_ctxt == imported)
     return;
 
   for(QVector<DUContext::Import>::const_iterator parentIt = m_importedContexts.constBegin(); parentIt != m_importedContexts.constEnd(); ++parentIt) {
     TopDUContext* top = dynamic_cast<TopDUContext*>(const_cast<DUContext*>(parentIt->context(nullptr))); //To avoid detaching, use const iterator
     if(top) {
 //       top->m_local->needImportStructure();
       if(top == imported) {
         addImportedContextRecursion(top, imported, 1);
       }else{
         RecursiveImports::const_iterator it2 = top->m_local->m_recursiveImports.constFind(imported);
         if(it2 != top->m_local->m_recursiveImports.constEnd()) {
 
           addImportedContextRecursion(top, imported, (*it2).first + 1);
         }
       }
     }
   }
 
   for(unsigned int a = 0; a < m_ctxt->d_func()->m_importedContextsSize(); ++a) {
   TopDUContext* top = dynamic_cast<TopDUContext*>(const_cast<DUContext*>(m_ctxt->d_func()->m_importedContexts()[a].context(nullptr))); //To avoid detaching, use const iterator
     if(top) {
 //       top->m_local->needImportStructure();
       if(top == imported) {
         addImportedContextRecursion(top, imported, 1);
       }else{
         RecursiveImports::const_iterator it2 = top->m_local->m_recursiveImports.constFind(imported);
         if(it2 != top->m_local->m_recursiveImports.constEnd()) {
 
           addImportedContextRecursion(top, imported, (*it2).first + 1);
         }
       }
     }
   }
 }
 
 void TopDUContext::rebuildDynamicImportStructure() {
   m_local->rebuildDynamicImportStructure();
 }
 
 void TopDUContext::rebuildDynamicData(DUContext* parent, uint ownIndex) {
   Q_ASSERT(parent == nullptr && ownIndex != 0);
   m_local->m_ownIndex = ownIndex;
 
   DUContext::rebuildDynamicData(parent, 0);
 }
 
 IndexedTopDUContext TopDUContext::indexed() const {
   return IndexedTopDUContext(m_local->m_ownIndex);
 }
 
 uint TopDUContext::ownIndex() const
 {
   return m_local->m_ownIndex;
 }
 
 TopDUContext::TopDUContext(TopDUContextData& data) : DUContext(data), m_local(new TopDUContextLocalPrivate(this, data.m_ownIndex)), m_dynamicData(new TopDUContextDynamicData(this)) {
 }
 
 TopDUContext::TopDUContext(const IndexedString& url, const RangeInRevision& range, ParsingEnvironmentFile* file)
 : DUContext(*new TopDUContextData(url), range)
 , m_local(new TopDUContextLocalPrivate(this, DUChain::newTopContextIndex()))
 , m_dynamicData(new TopDUContextDynamicData(this))
 {
   Q_ASSERT(url.toUrl().isValid() && !url.toUrl().isRelative());
   d_func_dynamic()->setClassId(this);
   setType(Global);
 
   DUCHAIN_D_DYNAMIC(TopDUContext);
   d->m_features = VisibleDeclarationsAndContexts;
   d->m_ownIndex = m_local->m_ownIndex;
   setParsingEnvironmentFile(file);
   setInSymbolTable(true);
 }
 
 QExplicitlySharedDataPointer<ParsingEnvironmentFile> TopDUContext::parsingEnvironmentFile() const {
   return m_local->m_file;
 }
 
 TopDUContext::~TopDUContext( )
 {
   m_dynamicData->m_deleting = true;
 
   //Clear the AST, so that the 'feature satisfaction' cache is eventually updated
   clearAst();
 
   if(!isOnDisk())
   {
     //Clear the 'feature satisfaction' cache which is managed in ParsingEnvironmentFile
     setFeatures(Empty);
 
     clearUsedDeclarationIndices();
   }
 
   deleteChildContextsRecursively();
   deleteLocalDeclarations();
   m_dynamicData->clear();
 }
 
 void TopDUContext::deleteSelf() {
   //We've got to make sure that m_dynamicData and m_local are still valid while all the sub-contexts are destroyed
   TopDUContextLocalPrivate* local = m_local;
   TopDUContextDynamicData* dynamicData = m_dynamicData;
 
   m_dynamicData->m_deleting = true;
 
   delete this;
 
   delete local;
   delete dynamicData;
 }
 
 TopDUContext::Features TopDUContext::features() const
 {
   uint ret = d_func()->m_features;
 
   if(ast())
     ret |= TopDUContext::AST;
 
   return (TopDUContext::Features)ret;
 }
 
 void TopDUContext::setFeatures(Features features)
 {
   features = (TopDUContext::Features)(features & (~Recursive)); //Remove the "Recursive" flag since that's only for searching
   features = (TopDUContext::Features)(features & (~ForceUpdateRecursive)); //Remove the update flags
   features = (TopDUContext::Features)(features & (~AST)); //Remove the AST flag, it's only used while updating
   d_func_dynamic()->m_features = features;
 
   //Replicate features to ParsingEnvironmentFile
   if(parsingEnvironmentFile())
     parsingEnvironmentFile()->setFeatures(this->features());
 }
 
 void TopDUContext::setAst(const QExplicitlySharedDataPointer<IAstContainer>& ast)
 {
   ENSURE_CAN_WRITE
   m_local->m_ast = ast;
 
   if(parsingEnvironmentFile())
     parsingEnvironmentFile()->setFeatures(features());
 }
 
 void TopDUContext::setParsingEnvironmentFile(ParsingEnvironmentFile* file)
 {
   if(m_local->m_file) //Clear the "feature satisfaction" cache
     m_local->m_file->setFeatures(Empty);
 
   //We do not enforce a duchain lock here, since this is also used while loading a top-context
   m_local->m_file = QExplicitlySharedDataPointer<ParsingEnvironmentFile>(file);
 
   //Replicate features to ParsingEnvironmentFile
   if(file) {
     file->setTopContext(IndexedTopDUContext(ownIndex()));
     Q_ASSERT(file->indexedTopContext().isValid());
     file->setFeatures(d_func()->m_features);
 
     file->setImportsCache(d_func()->m_importsCache);
   }
 }
 
 struct TopDUContext::FindDeclarationsAcceptor {
   FindDeclarationsAcceptor(const TopDUContext* _top, DeclarationList& _target, const DeclarationChecker& _check, SearchFlags _flags) : top(_top), target(_target), check(_check) {
     flags = _flags;
   }
 
   bool operator() (const QualifiedIdentifier& id) {
 
 #ifdef DEBUG_SEARCH
     qCDebug(LANGUAGE) << "accepting" << id.toString();
 #endif
 
     PersistentSymbolTable::Declarations allDecls;
 
     //This iterator efficiently filters the visible declarations out of all declarations
     PersistentSymbolTable::FilteredDeclarationIterator filter;
 
     //This is used if filtering is disabled
     PersistentSymbolTable::Declarations::Iterator unchecked;
     if(check.flags & DUContext::NoImportsCheck) {
-      allDecls = PersistentSymbolTable::self().getDeclarations(id);
+      allDecls = PersistentSymbolTable::self().declarations(id);
       unchecked = allDecls.iterator();
     } else
-      filter = PersistentSymbolTable::self().getFilteredDeclarations(id, top->recursiveImportIndices());
+      filter = PersistentSymbolTable::self().filteredDeclarations(id, top->recursiveImportIndices());
 
     while(filter || unchecked) {
 
       IndexedDeclaration iDecl;
       if(filter) {
         iDecl = *filter;
         ++filter;
       } else {
         iDecl = *unchecked;
         ++unchecked;
       }
       Declaration* decl = iDecl.data();
 
       if(!decl)
         continue;
 
       if(!check(decl))
         continue;
 
       if( ! (flags & DontResolveAliases) && decl->kind() == Declaration::Alias ) {
         //Apply alias declarations
         AliasDeclaration* alias = static_cast<AliasDeclaration*>(decl);
         if(alias->aliasedDeclaration().isValid()) {
           decl = alias->aliasedDeclaration().declaration();
         } else {
           qCDebug(LANGUAGE) << "lost aliased declaration";
         }
       }
 
 
       target.append(decl);
     }
 
     check.createVisibleCache = nullptr;
 
     return !top->foundEnough(target, flags);
   }
 
   const TopDUContext* top;
   DeclarationList& target;
   const DeclarationChecker& check;
   QFlags< KDevelop::DUContext::SearchFlag > flags;
 };
 
 bool TopDUContext::findDeclarationsInternal(const SearchItem::PtrList& identifiers, const CursorInRevision& position, const AbstractType::Ptr& dataType, DeclarationList& ret, const TopDUContext* /*source*/, SearchFlags flags, uint /*depth*/) const
 {
   ENSURE_CAN_READ
 
 #ifdef DEBUG_SEARCH
   for (const SearchItem::Ptr& idTree : identifiers)
       foreach(const QualifiedIdentifier &id, idTree->toList())
         qCDebug(LANGUAGE) << "searching item" << id.toString();
 #endif
 
   DeclarationChecker check(this, position, dataType, flags);
   FindDeclarationsAcceptor storer(this, ret, check, flags);
 
   ///The actual scopes are found within applyAliases, and each complete qualified identifier is given to FindDeclarationsAcceptor.
   ///That stores the found declaration to the output.
   applyAliases(identifiers, storer, position, false);
 
   return true;
 }
 
 //This is used to prevent endless recursion due to "using namespace .." declarations, by storing all imports that are already being used.
 struct TopDUContext::ApplyAliasesBuddyInfo {
   ApplyAliasesBuddyInfo(uint importChainType, ApplyAliasesBuddyInfo* predecessor, const IndexedQualifiedIdentifier& importId) : m_importChainType(importChainType), m_predecessor(predecessor), m_importId(importId) {
     if(m_predecessor && m_predecessor->m_importChainType != importChainType)
       m_predecessor = nullptr;
   }
 
   bool alreadyImporting(const IndexedQualifiedIdentifier& id) {
     ApplyAliasesBuddyInfo* current = this;
     while(current) {
       if(current->m_importId == id)
         return true;
       current = current->m_predecessor;
     }
     return false;
   }
 
   uint m_importChainType;
   ApplyAliasesBuddyInfo* m_predecessor;
   IndexedQualifiedIdentifier m_importId;
 };
 
 ///@todo Implement a cache so at least the global import checks don't need to be done repeatedly. The cache should be thread-local, using DUChainPointer for the hashed items, and when an item was deleted, it should be discarded
 template<class Acceptor>
 bool TopDUContext::applyAliases( const QualifiedIdentifier& previous, const SearchItem::Ptr& identifier, Acceptor& accept, const CursorInRevision& position, bool canBeNamespace, ApplyAliasesBuddyInfo* buddy, uint recursionDepth ) const
 {
   if(recursionDepth > maxApplyAliasesRecursion) {
     const auto searches = identifier->toList();
     QualifiedIdentifier id;
     if(!searches.isEmpty())
       id = searches.first();
 
     qCDebug(LANGUAGE) << "maximum apply-aliases recursion reached while searching" << id;
   }
   bool foundAlias = false;
 
   QualifiedIdentifier id(previous);
   id.push(identifier->identifier);
 
   if(!id.inRepository())
     return true; //If the qualified identifier is not in the identifier repository, it cannot be registered anywhere, so there's nothing we need to do
 
   if( !identifier->next.isEmpty() || canBeNamespace ) { //If it cannot be a namespace, the last part of the scope will be ignored
 
     //Search for namespace-aliases, by using globalAliasIdentifier, which is inserted into the symbol-table by NamespaceAliasDeclaration
     QualifiedIdentifier aliasId(id);
     aliasId.push(globalIndexedAliasIdentifier());
 
 #ifdef DEBUG_SEARCH
   qCDebug(LANGUAGE) << "checking" << id.toString();
 #endif
 
     if(aliasId.inRepository()) {
     //This iterator efficiently filters the visible declarations out of all declarations
-      PersistentSymbolTable::FilteredDeclarationIterator filter = PersistentSymbolTable::self().getFilteredDeclarations(aliasId, recursiveImportIndices());
+      PersistentSymbolTable::FilteredDeclarationIterator filter = PersistentSymbolTable::self().filteredDeclarations(aliasId, recursiveImportIndices());
 
       if(filter) {
         DeclarationChecker check(this, position, AbstractType::Ptr(), NoSearchFlags, nullptr);
 
         //The first part of the identifier has been found as a namespace-alias.
         //In c++, we only need the first alias. However, just to be correct, follow them all for now.
         for(; filter; ++filter)
         {
           Declaration* aliasDecl = filter->data();
           if(!aliasDecl)
             continue;
 
           if(!check(aliasDecl))
             continue;
 
           if(aliasDecl->kind() != Declaration::NamespaceAlias)
             continue;
 
           if(foundAlias)
               break;
 
           Q_ASSERT(dynamic_cast<NamespaceAliasDeclaration*>(aliasDecl));
 
           NamespaceAliasDeclaration* alias = static_cast<NamespaceAliasDeclaration*>(aliasDecl);
 
           foundAlias = true;
 
           QualifiedIdentifier importIdentifier = alias->importIdentifier();
 
           if(importIdentifier.isEmpty()) {
             qCDebug(LANGUAGE) << "found empty import";
             continue;
           }
 
           if(buddy && buddy->alreadyImporting( importIdentifier ))
             continue; //This import has already been applied to this search
 
           ApplyAliasesBuddyInfo info(1, buddy, importIdentifier);
 
           if(identifier->next.isEmpty()) {
             //Just insert the aliased namespace identifier
             if(!accept(importIdentifier))
               return false;
           }else{
             //Create an identifiers where namespace-alias part is replaced with the alias target
             foreach (const SearchItem::Ptr& item, identifier->next)
               if(!applyAliases(importIdentifier, item, accept, position, canBeNamespace, &info, recursionDepth+1))
                 return false;
           }
         }
       }
     }
   }
 
   if(!foundAlias) { //If we haven't found an alias, put the current versions into the result list. Additionally we will compute the identifiers transformed through "using".
     if(identifier->next.isEmpty()) {
       if(!accept(id)) //We're at the end of a qualified identifier, accept it
         return false;
     } else {
       foreach (const SearchItem::Ptr& next, identifier->next)
         if(!applyAliases(id, next, accept, position, canBeNamespace, nullptr, recursionDepth+1))
           return false;
     }
   }
 
   /*if( !prefix.explicitlyGlobal() || !prefix.isEmpty() ) {*/ ///@todo check iso c++ if using-directives should be respected on top-level when explicitly global
   ///@todo this is bad for a very big repository(the chains should be walked for the top-context instead)
 
   //Find all namespace-imports at given scope
 
   {
     QualifiedIdentifier importId(previous);
     importId.push(globalIndexedImportIdentifier());
 
 #ifdef DEBUG_SEARCH
 //   qCDebug(LANGUAGE) << "checking imports in" << (backPointer ? id.toString() : QStringLiteral("global"));
 #endif
 
     if(importId.inRepository()) {
       //This iterator efficiently filters the visible declarations out of all declarations
-      PersistentSymbolTable::FilteredDeclarationIterator filter = PersistentSymbolTable::self().getFilteredDeclarations(importId, recursiveImportIndices());
+      PersistentSymbolTable::FilteredDeclarationIterator filter = PersistentSymbolTable::self().filteredDeclarations(importId, recursiveImportIndices());
 
       if(filter) {
         DeclarationChecker check(this, position, AbstractType::Ptr(), NoSearchFlags, nullptr);
 
         for(; filter; ++filter)
         {
           Declaration* importDecl = filter->data();
           if(!importDecl)
             continue;
 
           //We must never break or return from this loop, because else we might be creating a bad cache
           if(!check(importDecl))
             continue;
 
           //Search for the identifier with the import-identifier prepended
           Q_ASSERT(dynamic_cast<NamespaceAliasDeclaration*>(importDecl));
           NamespaceAliasDeclaration* alias = static_cast<NamespaceAliasDeclaration*>(importDecl);
 
   #ifdef DEBUG_SEARCH
           qCDebug(LANGUAGE) << "found import of" << alias->importIdentifier().toString();
   #endif
 
           QualifiedIdentifier importIdentifier = alias->importIdentifier();
 
           if(importIdentifier.isEmpty()) {
             qCDebug(LANGUAGE) << "found empty import";
             continue;
           }
 
           if(buddy && buddy->alreadyImporting( importIdentifier ))
             continue; //This import has already been applied to this search
 
           ApplyAliasesBuddyInfo info(2, buddy, importIdentifier);
 
           if(previous != importIdentifier)
             if(!applyAliases(importIdentifier, identifier, accept, importDecl->topContext() == this ? importDecl->range().start : position, canBeNamespace, &info, recursionDepth+1))
               return false;
         }
       }
     }
   }
   return true;
 }
 
 template<class Acceptor>
 void TopDUContext::applyAliases( const SearchItem::PtrList& identifiers, Acceptor& acceptor, const CursorInRevision& position, bool canBeNamespace ) const
 {
   QualifiedIdentifier emptyId;
 
   for (const SearchItem::Ptr& item : identifiers)
     applyAliases(emptyId, item, acceptor, position, canBeNamespace, nullptr, 0);
 }
 
 TopDUContext * TopDUContext::topContext() const
 {
   return const_cast<TopDUContext*>(this);
 }
 
 bool TopDUContext::deleting() const
 {
   return m_dynamicData->m_deleting;
 }
 
 QList<ProblemPointer> TopDUContext::problems() const
 {
   ENSURE_CAN_READ
 
   const auto data = d_func();
   QList<ProblemPointer> ret;
   ret.reserve(data->m_problemsSize());
   for (uint i = 0; i < data->m_problemsSize(); ++i) {
     ret << ProblemPointer(data->m_problems()[i].data(this));
   }
   return ret;
 }
 
 void TopDUContext::setProblems(const QList<ProblemPointer>& problems)
 {
   ENSURE_CAN_WRITE
   clearProblems();
   for (const auto& problem : problems) {
     addProblem(problem);
   }
 }
 
 void TopDUContext::addProblem(const ProblemPointer& problem)
 {
   ENSURE_CAN_WRITE
 
   Q_ASSERT(problem);
 
   auto data = d_func_dynamic();
   // store for indexing
   LocalIndexedProblem indexedProblem(problem, this);
   Q_ASSERT(indexedProblem.isValid());
   data->m_problemsList().append(indexedProblem);
   Q_ASSERT(indexedProblem.data(this));
 }
 
 void TopDUContext::clearProblems()
 {
   ENSURE_CAN_WRITE
   d_func_dynamic()->m_problemsList().clear();
   m_dynamicData->clearProblems();
 }
 
 QVector<DUContext*> TopDUContext::importers() const
 {
   ENSURE_CAN_READ
   return QVector<DUContext*>::fromList( m_local->m_directImporters.toList() );
 }
 
 QList<DUContext*> TopDUContext::loadedImporters() const
 {
   ENSURE_CAN_READ
   return m_local->m_directImporters.toList();
 }
 
 QVector<DUContext::Import> TopDUContext::importedParentContexts() const
 {
   ENSURE_CAN_READ
   return DUContext::importedParentContexts();
 }
 
 bool TopDUContext::imports(const DUContext * origin, const CursorInRevision& position) const
 {
   return importsPrivate(origin, position);
 }
 
 bool TopDUContext::importsPrivate(const DUContext * origin, const CursorInRevision& position) const
 {
   Q_UNUSED(position);
 
   if( const TopDUContext* top = dynamic_cast<const TopDUContext*>(origin) ) {
     QMutexLocker lock(&importStructureMutex);
     bool ret = recursiveImportIndices().contains(IndexedTopDUContext(const_cast<TopDUContext*>(top)));
     if(top == this)
       Q_ASSERT(ret);
     return ret;
   } else {
     //Cannot import a non top-context
     return false;
   }
  }
 
 void TopDUContext::clearImportedParentContexts() {
   if(usingImportsCache()) {
     d_func_dynamic()->m_importsCache = IndexedRecursiveImports();
     d_func_dynamic()->m_importsCache.insert(IndexedTopDUContext(this));
   }
 
   DUContext::clearImportedParentContexts();
 
   m_local->clearImportedContextsRecursively();
 
   Q_ASSERT(m_local->m_recursiveImports.count() == 0);
 
   Q_ASSERT(m_local->m_indexedRecursiveImports.count() == 1);
 
   Q_ASSERT(imports(this, CursorInRevision::invalid()));
 }
 
 void TopDUContext::addImportedParentContext(DUContext* context, const CursorInRevision& position, bool anonymous, bool temporary) {
   if(context == this)
     return;
 
   if(!dynamic_cast<TopDUContext*>(context)) {
     //We cannot do this, because of the extended way we treat top-context imports.
     qCDebug(LANGUAGE) << "tried to import a non top-context into a top-context. This is not possible.";
     return;
   }
 
   //Always make the contexts anonymous, because we care about importers in TopDUContextLocalPrivate
   DUContext::addImportedParentContext(context, position, anonymous, temporary);
 
   m_local->addImportedContextRecursively(static_cast<TopDUContext*>(context), temporary, true);
 }
 
 void TopDUContext::removeImportedParentContext(DUContext* context) {
   DUContext::removeImportedParentContext(context);
 
   m_local->removeImportedContextRecursively(static_cast<TopDUContext*>(context), true);
 }
 
 void TopDUContext::addImportedParentContexts(const QVector<QPair<TopDUContext*, CursorInRevision>>& contexts, bool temporary) {
   typedef QPair<TopDUContext*, CursorInRevision> Pair;
 
   for (const Pair pair : contexts) {
     addImportedParentContext(pair.first, pair.second, false, temporary);
   }
 }
 
 void TopDUContext::removeImportedParentContexts(const QList<TopDUContext*>& contexts) {
   for (TopDUContext* context : contexts) {
     DUContext::removeImportedParentContext(context);
   }
 
   m_local->removeImportedContextsRecursively(contexts, true);
 }
 
 /// Returns true if this object is registered in the du-chain. If it is not, all sub-objects(context, declarations, etc.)
 bool TopDUContext::inDUChain() const {
   return m_local->m_inDuChain;
 }
 
 /// This flag is only used by DUChain, never change it from outside.
 void TopDUContext::setInDuChain(bool b) {
   m_local->m_inDuChain = b;
 }
 
 bool TopDUContext::isOnDisk() const {
   ///@todo Change this to releasingToDisk, and only enable it while saving a top-context to disk.
   return m_dynamicData->isOnDisk();
 }
 
 void TopDUContext::clearUsedDeclarationIndices() {
   ENSURE_CAN_WRITE
   for(unsigned int a = 0; a < d_func()->m_usedDeclarationIdsSize(); ++a)
       DUChain::uses()->removeUse(d_func()->m_usedDeclarationIds()[a], this);
 
   d_func_dynamic()->m_usedDeclarationIdsList().clear();
 }
 
 void TopDUContext::deleteUsesRecursively()
 {
     clearUsedDeclarationIndices();
     KDevelop::DUContext::deleteUsesRecursively();
 }
 
 Declaration* TopDUContext::usedDeclarationForIndex(unsigned int declarationIndex) const {
   ENSURE_CAN_READ
   if(declarationIndex & (1<<31)) {
     //We use the highest bit to mark direct indices into the local declarations
     declarationIndex &= ~(1<<31); //unset the highest bit
-    return m_dynamicData->getDeclarationForIndex(declarationIndex);
+    return m_dynamicData->declarationForIndex(declarationIndex);
   }else if(declarationIndex < d_func()->m_usedDeclarationIdsSize())
-    return d_func()->m_usedDeclarationIds()[declarationIndex].getDeclaration(this);
+    return d_func()->m_usedDeclarationIds()[declarationIndex].declaration(this);
   else
     return nullptr;
 }
 
 int TopDUContext::indexForUsedDeclaration(Declaration* declaration, bool create) {
   if(create) {
     ENSURE_CAN_WRITE
   }else{
     ENSURE_CAN_READ
   }
 
   if(!declaration) {
     return std::numeric_limits<int>::max();
   }
 
   if(declaration->topContext() == this && !declaration->inSymbolTable() && !m_dynamicData->isTemporaryDeclarationIndex(declaration->ownIndex())) {
     uint index = declaration->ownIndex();
     Q_ASSERT(!(index & (1<<31)));
     return (int)(index | (1<<31)); //We don't put context-local declarations into the list, that's a waste. We just use the mark them with the highest bit.
   }
 
   // if the declaration can not be found from this top-context, we create a direct
   // reference by index, to ensure that the use can be resolved in
   // usedDeclarationForIndex
   bool useDirectId = !recursiveImportIndices().contains(declaration->topContext());
   DeclarationId id(declaration->id(useDirectId));
 
   int index = -1;
 
   uint size = d_func()->m_usedDeclarationIdsSize();
   const DeclarationId* ids = d_func()->m_usedDeclarationIds();
 
   ///@todo Make m_usedDeclarationIds sorted, and find the decl. using binary search
   for(unsigned int a = 0; a < size; ++a)
     if(ids[a] == id) {
       index = a;
       break;
     }
 
   if(index != -1)
     return index;
   if(!create)
     return std::numeric_limits<int>::max();
 
   d_func_dynamic()->m_usedDeclarationIdsList().append(id);
 
   if(declaration->topContext() != this)
     DUChain::uses()->addUse(id, this);
 
   return d_func()->m_usedDeclarationIdsSize()-1;
 }
 
 QVector<RangeInRevision> allUses(TopDUContext* context, Declaration* declaration, bool noEmptyRanges)
 {
   QVector<RangeInRevision> ret;
   int declarationIndex = context->indexForUsedDeclaration(declaration, false);
   if(declarationIndex == std::numeric_limits<int>::max())
     return ret;
   return allUses(context, declarationIndex, noEmptyRanges);
 }
 
 QExplicitlySharedDataPointer<IAstContainer> TopDUContext::ast() const
 {
   return m_local->m_ast;
 }
 
 void TopDUContext::clearAst()
 {
   setAst(QExplicitlySharedDataPointer<IAstContainer>(nullptr));
 }
 
 IndexedString TopDUContext::url() const {
   return d_func()->m_url;
 }
 
 }
diff --git a/kdevplatform/language/duchain/topducontextdynamicdata.cpp b/kdevplatform/language/duchain/topducontextdynamicdata.cpp
index 5f0088f01c..c5e580ad0e 100644
--- a/kdevplatform/language/duchain/topducontextdynamicdata.cpp
+++ b/kdevplatform/language/duchain/topducontextdynamicdata.cpp
@@ -1,855 +1,855 @@
 /* This  is part of KDevelop
 
    Copyright 2014 Milian Wolff <mail@milianw.de>
    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 "topducontextdynamicdata.h"
 
 #include <typeinfo>
 #include <QFile>
 #include <QByteArray>
 
 #include "declaration.h"
 #include "declarationdata.h"
 #include "ducontext.h"
 #include "topducontext.h"
 #include "topducontextdata.h"
 #include "ducontextdata.h"
 #include "ducontextdynamicdata.h"
 #include "duchainregister.h"
 #include "serialization/itemrepository.h"
 #include "problem.h"
 #include <debug.h>
 
 //#define DEBUG_DATA_INFO
 
 //This might be problematic on some systems, because really many mmaps are created
 #define USE_MMAP
 using namespace KDevelop;
 
 namespace {
 
 /**
  * Serialize @p item into @p data and update @p totalDataOffset.
  *
  * If @p isSharedDataItem is true, then the item's internal data pointer is not updated
  * to point to the serialized data. Otherwise the dynamic data is deleted and the items
  * data will point to the constant serialized data.
  *
  * NOTE: The above is required to support serialization of shared-data such as from ProblemPointer.
  * If we'd set the data to point to the constant region, we'd get crashes due to use-after-free when
  * we unmap the data and a shared pointer outlives that.
  */
 void saveDUChainItem(QVector<TopDUContextDynamicData::ArrayWithPosition>& data, DUChainBase& item, uint& totalDataOffset, bool isSharedDataItem)
 {
   if(!item.d_func()->classId) {
     //If this triggers, you have probably created an own DUChainBase based class, but haven't called setClassId(this) in the constructor.
     qCritical() << "no class-id set for data attached to a declaration of type" << typeid(item).name();
     Q_ASSERT(0);
   }
 
   int size = DUChainItemSystem::self().dynamicSize(*item.d_func());
 
   if(data.back().array.size() - int(data.back().position) < size)
       //Create a new data item
       data.append({QByteArray(size > 10000 ? size : 10000, 0), 0u});
 
   uint pos = data.back().position;
   data.back().position += size;
   totalDataOffset += size;
 
   DUChainBaseData& target(*(reinterpret_cast<DUChainBaseData*>(data.back().array.data() + pos)));
 
   if(item.d_func()->isDynamic()) {
     //Change from dynamic data to constant data
 
     enableDUChainReferenceCounting(data.back().array.data(), data.back().array.size());
     DUChainItemSystem::self().copy(*item.d_func(), target, true);
     Q_ASSERT(!target.isDynamic());
     if (!isSharedDataItem) {
       item.setData(&target);
     }
     disableDUChainReferenceCounting(data.back().array.data());
   }else{
     //Just copy the data into another place, expensive copy constructors are not needed
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 800)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #endif
     memcpy(&target, item.d_func(), size);
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 800)
 #pragma GCC diagnostic pop
 #endif
     if (!isSharedDataItem) {
       item.setData(&target, false);
     }
   }
 
   if (!isSharedDataItem) {
     Q_ASSERT(item.d_func() == &target);
 
     Q_ASSERT(!item.d_func()->isDynamic());
   }
 }
 
 uint indexForParentContext(DUContext* context)
 {
   return LocalIndexedDUContext(context->parentContext()).localIndex();
 }
 
 uint indexForParentContext(Declaration* declaration)
 {
   return LocalIndexedDUContext(declaration->context()).localIndex();
 }
 
 uint indexForParentContext(const ProblemPointer& /*problem*/)
 {
   // always stored in the top context
   return 0;
 }
 
 #ifndef QT_NO_DEBUG
 void validateItem(const DUChainBaseData* const data, const uchar* const mappedData, const size_t mappedDataSize)
 {
   Q_ASSERT(!data->isDynamic());
   if (mappedData) {
     Q_ASSERT(((size_t)data) < ((size_t)mappedData)
           || ((size_t)data) > ((size_t)mappedData) + mappedDataSize);
   }
 }
 #endif
 
 const char* pointerInData(const QVector<TopDUContextDynamicData::ArrayWithPosition>& data, uint totalOffset)
 {
   for(int a = 0; a < data.size(); ++a) {
     if(totalOffset < data[a].position)
       return data[a].array.constData() + totalOffset;
     totalOffset -= data[a].position;
   }
   Q_ASSERT_X(false, Q_FUNC_INFO, "Offset doesn't exist in the data.");
   return nullptr;
 }
 
 void verifyDataInfo(const TopDUContextDynamicData::ItemDataInfo& info, const QVector<TopDUContextDynamicData::ArrayWithPosition>& data)
 {
   Q_UNUSED(info);
   Q_UNUSED(data);
 #ifdef DEBUG_DATA_INFO
   DUChainBaseData* item = (DUChainBaseData*)(pointerInData(data, info.dataOffset));
   int size = DUChainItemSystem::self().dynamicSize(*item);
   Q_ASSERT(size);
 #endif
 }
 
 QString basePath()
 {
   return globalItemRepositoryRegistry().path() + QLatin1String("/topcontexts/");
 }
 
 QString pathForTopContext(const uint topContextIndex)
 {
   return basePath() + QString::number(topContextIndex);
 }
 
 enum LoadType {
   PartialLoad, ///< Only load the direct member data
   FullLoad     ///< Load everything, including appended lists
 };
 template<typename F>
 void loadTopDUContextData(const uint topContextIndex, LoadType loadType, F callback)
 {
   QFile file(pathForTopContext(topContextIndex));
   if (!file.open(QIODevice::ReadOnly)) {
     return;
   }
 
   uint readValue;
   file.read((char*)&readValue, sizeof(uint));
   // now readValue is filled with the top-context data size
   Q_ASSERT(readValue >= sizeof(TopDUContextData));
   const QByteArray data = file.read(loadType == FullLoad ? readValue : sizeof(TopDUContextData));
   const TopDUContextData* topData = reinterpret_cast<const TopDUContextData*>(data.constData());
   callback(topData);
 }
 
 template<typename T>
 struct PtrType;
 
 template<typename T>
 struct PtrType<T*>
 {
   using value = T*;
 };
 
 template<typename T>
 struct PtrType<QExplicitlySharedDataPointer<T>>
 {
   using value = T*;
 };
 
 template<typename T>
 Q_DECL_CONSTEXPR bool isSharedDataItem()
 {
   return false;
 }
 
 template<>
 Q_DECL_CONSTEXPR bool isSharedDataItem<ProblemPointer>()
 {
   return true;
 }
 
 }
 
 //BEGIN DUChainItemStorage
 
 template<class Item>
 TopDUContextDynamicData::DUChainItemStorage<Item>::DUChainItemStorage(TopDUContextDynamicData* data)
   : data(data)
 {
 }
 
 template<class Item>
 TopDUContextDynamicData::DUChainItemStorage<Item>::~DUChainItemStorage()
 {
   clearItems();
 }
 
 template<class Item>
 void TopDUContextDynamicData::DUChainItemStorage<Item>::clearItems()
 {
   //Due to template specialization it's possible that a declaration is not reachable through the normal context structure.
   //For that reason we have to check here, and delete all remaining declarations.
   qDeleteAll(temporaryItems);
   temporaryItems.clear();
   qDeleteAll(items);
   items.clear();
 }
 
 namespace KDevelop {
 template<>
 void TopDUContextDynamicData::DUChainItemStorage<ProblemPointer>::clearItems()
 {
   // don't delete anything - the problem is shared
   items.clear();
 }
 }
 
 template<class Item>
 void TopDUContextDynamicData::DUChainItemStorage<Item>::clearItemIndex(const Item& item, const uint index)
 {
   if(!data->m_dataLoaded)
     data->loadData();
 
   if (index < (0x0fffffff/2)) {
     if (index == 0 || index > uint(items.size())) {
       return;
     } else {
       const uint realIndex = index - 1;
       Q_ASSERT(items[realIndex] == item);
       items[realIndex] = nullptr;
 
       if (realIndex < (uint)offsets.size()) {
         offsets[realIndex] = ItemDataInfo();
       }
     }
   } else {
     const uint realIndex = 0x0fffffff - index; //We always keep the highest bit at zero
     if (realIndex == 0 || realIndex > uint(temporaryItems.size())) {
       return;
     } else {
       Q_ASSERT(temporaryItems[realIndex-1] == item);
       temporaryItems[realIndex-1] = nullptr;
     }
   }
 
   Q_UNUSED(item);
 }
 
 template<class Item>
 void TopDUContextDynamicData::DUChainItemStorage<Item>::storeData(uint& currentDataOffset,
                                                                   const QVector<ArrayWithPosition>& oldData)
 {
   auto const oldOffsets = offsets;
   offsets.clear();
   offsets.reserve(items.size());
   for (int a = 0; a < items.size(); ++a) {
     auto item = items[a];
     if (!item) {
       if (oldOffsets.size() > a && oldOffsets[a].dataOffset) {
         //Directly copy the old data range into the new data
         const DUChainBaseData* itemData = nullptr;
         if (data->m_mappedData) {
           itemData = reinterpret_cast<const DUChainBaseData*>(data->m_mappedData + oldOffsets[a].dataOffset);
         } else {
           itemData = reinterpret_cast<const DUChainBaseData*>(::pointerInData(oldData, oldOffsets[a].dataOffset));
         }
         offsets << data->writeDataInfo(oldOffsets[a], itemData, currentDataOffset);
       } else {
         offsets << ItemDataInfo();
       }
     } else {
       offsets << ItemDataInfo{currentDataOffset, indexForParentContext(item)};
       saveDUChainItem(data->m_data, *item, currentDataOffset, isSharedDataItem<Item>());
     }
   }
 
 #ifndef QT_NO_DEBUG
   if (!isSharedDataItem<Item>()) {
     for (auto item : items) {
       if (item) {
         validateItem(item->d_func(), data->m_mappedData, data->m_mappedDataSize);
       }
     }
   }
 #endif
 }
 
 template<typename Item>
 bool TopDUContextDynamicData::DUChainItemStorage<Item>::itemsHaveChanged() const
 {
   for (auto item : items) {
     if (item && item->d_func()->m_dynamic) {
       return true;
     }
   }
   return false;
 }
 
 template<class Item>
 uint TopDUContextDynamicData::DUChainItemStorage<Item>::allocateItemIndex(const Item& item, const bool temporary)
 {
   if (!data->m_dataLoaded) {
     data->loadData();
   }
   if (!temporary) {
     items.append(item);
     return items.size();
   } else {
     temporaryItems.append(item);
     return 0x0fffffff - temporaryItems.size(); //We always keep the highest bit at zero
   }
 }
 
 template<class Item>
 bool TopDUContextDynamicData::DUChainItemStorage<Item>::isItemForIndexLoaded(uint index) const
 {
   if (!data->m_dataLoaded) {
     return false;
   }
   if (index < (0x0fffffff/2)) {
     if (index == 0 || index > uint(items.size())) {
       return false;
     }
     return items[index-1];
   } else {
     // temporary item
     return true;
   }
 }
 
 template<class Item>
-Item TopDUContextDynamicData::DUChainItemStorage<Item>::getItemForIndex(uint index) const
+Item TopDUContextDynamicData::DUChainItemStorage<Item>::itemForIndex(uint index) const
 {
   if (index >= (0x0fffffff/2)) {
     index = 0x0fffffff - index; //We always keep the highest bit at zero
     if(index == 0 || index > uint(temporaryItems.size()))
       return {};
     else
       return temporaryItems.at(index-1);
   }
 
   if (index == 0 || index > static_cast<uint>(items.size())) {
     qCWarning(LANGUAGE) << "item index out of bounds:" << index << "count:" << items.size();
     return {};
   }
   const uint realIndex = index - 1;
   const auto& item = items.at(realIndex);
   if (item) {
     //Shortcut, because this is the most common case
     return item;
   }
 
   if (realIndex < (uint)offsets.size() && offsets[realIndex].dataOffset) {
     Q_ASSERT(!data->m_itemRetrievalForbidden);
 
     //Construct the context, and eventuall its parent first
     ///TODO: ugly, remove need for const_cast
     auto itemData = const_cast<DUChainBaseData*>(
       reinterpret_cast<const DUChainBaseData*>(data->pointerInData(offsets[realIndex].dataOffset))
     );
 
     auto& item = items[realIndex];
     item = dynamic_cast<typename PtrType<Item>::value>(DUChainItemSystem::self().create(itemData));
     if (!item) {
       //When this happens, the item has not been registered correctly.
       //We can stop here, because else we will get crashes later.
       qCritical() << "Failed to load item with identity" << itemData->classId;
       return {};
     }
 
     if (isSharedDataItem<Item>()) {
       // NOTE: shared data must never point to mmapped data regions as otherwise we might end up with
       // use-after-free or double-deletions etc. pp.
       // thus, make the item always dynamic after deserialization
       item->makeDynamic();
     }
 
-    auto parent = data->getContextForIndex(offsets[realIndex].parentContext);
+    auto parent = data->contextForIndex(offsets[realIndex].parentContext);
     Q_ASSERT_X(parent, Q_FUNC_INFO, "Could not find parent context for loaded item.\n"
                                     "Potentially, the context has been deleted without deleting its children.");
     item->rebuildDynamicData(parent, index);
   } else {
     qCWarning(LANGUAGE) << "invalid item for index" << index << offsets.size() << offsets.value(realIndex).dataOffset;
   }
 
   return item;
 }
 
 template<class Item>
 void TopDUContextDynamicData::DUChainItemStorage<Item>::deleteOnDisk()
 {
   for (auto& item : items) {
     if (item) {
       item->makeDynamic();
     }
   }
 }
 
 template<class Item>
 void TopDUContextDynamicData::DUChainItemStorage<Item>::loadData(QFile* file) const
 {
   Q_ASSERT(offsets.isEmpty());
   Q_ASSERT(items.isEmpty());
 
   uint readValue;
   file->read((char*)&readValue, sizeof(uint));
   offsets.resize(readValue);
 
   file->read((char*)offsets.data(), sizeof(ItemDataInfo) * offsets.size());
 
   //Fill with zeroes for now, will be initialized on-demand
   items.resize(offsets.size());
 }
 
 template<class Item>
 void TopDUContextDynamicData::DUChainItemStorage<Item>::writeData(QFile* file)
 {
   uint writeValue = offsets.size();
   file->write((char*)&writeValue, sizeof(uint));
   file->write((char*)offsets.data(), sizeof(ItemDataInfo) * offsets.size());
 }
 
 //END DUChainItemStorage
 
 const char* TopDUContextDynamicData::pointerInData(uint totalOffset) const
 {
   Q_ASSERT(!m_mappedData || m_data.isEmpty());
 
   if(m_mappedData && m_mappedDataSize)
     return (char*)m_mappedData + totalOffset;
 
   return ::pointerInData(m_data, totalOffset);
 }
 
 TopDUContextDynamicData::TopDUContextDynamicData(TopDUContext* topContext)
   : m_deleting(false)
   , m_topContext(topContext)
   , m_contexts(this)
   , m_declarations(this)
   , m_problems(this)
   , m_onDisk(false)
   , m_dataLoaded(true)
   , m_mappedFile(nullptr)
   , m_mappedData(nullptr)
   , m_mappedDataSize(0)
   , m_itemRetrievalForbidden(false)
 {
 }
 
 void KDevelop::TopDUContextDynamicData::clear()
 {
   m_contexts.clearItems();
   m_declarations.clearItems();
   m_problems.clearItems();
 }
 
 TopDUContextDynamicData::~TopDUContextDynamicData()
 {
   unmap();
 }
 
 void KDevelop::TopDUContextDynamicData::unmap() {
   delete m_mappedFile;
   m_mappedFile = nullptr;
   m_mappedData = nullptr;
   m_mappedDataSize = 0;
 }
 
 bool TopDUContextDynamicData::fileExists(uint topContextIndex)
 {
   return QFile::exists(pathForTopContext(topContextIndex));
 }
 
 QList<IndexedDUContext> TopDUContextDynamicData::loadImporters(uint topContextIndex) {
   QList<IndexedDUContext> ret;
   loadTopDUContextData(topContextIndex, FullLoad, [&ret] (const TopDUContextData* topData) {
     ret.reserve(topData->m_importersSize());
     FOREACH_FUNCTION(const IndexedDUContext& importer, topData->m_importers)
       ret << importer;
   });
   return ret;
 }
 
 QList<IndexedDUContext> TopDUContextDynamicData::loadImports(uint topContextIndex) {
   QList<IndexedDUContext> ret;
   loadTopDUContextData(topContextIndex, FullLoad, [&ret] (const TopDUContextData* topData) {
     ret.reserve(topData->m_importedContextsSize());
     FOREACH_FUNCTION(const DUContext::Import& import, topData->m_importedContexts)
       ret << import.indexedContext();
   });
   return ret;
 }
 
 IndexedString TopDUContextDynamicData::loadUrl(uint topContextIndex) {
   IndexedString url;
   loadTopDUContextData(topContextIndex, PartialLoad, [&url] (const TopDUContextData* topData) {
     Q_ASSERT(topData->m_url.isEmpty() || topData->m_url.index() >> 16);
     url = topData->m_url;
   });
   return url;
 }
 
 void TopDUContextDynamicData::loadData() const {
   //This function has to be protected by an additional mutex, since it can be triggered from multiple threads at the same time
   static QMutex mutex;
   QMutexLocker lock(&mutex);
   if(m_dataLoaded)
     return;
 
   Q_ASSERT(!m_dataLoaded);
   Q_ASSERT(m_data.isEmpty());
 
   QFile* file = new QFile(pathForTopContext(m_topContext->ownIndex()));
   bool open = file->open(QIODevice::ReadOnly);
   Q_UNUSED(open);
   Q_ASSERT(open);
   Q_ASSERT(file->size());
 
   //Skip the offsets, we're already read them
   //Skip top-context data
   uint readValue;
   file->read((char*)&readValue, sizeof(uint));
   file->seek(readValue + file->pos());
 
   m_contexts.loadData(file);
   m_declarations.loadData(file);
   m_problems.loadData(file);
 
 #ifdef USE_MMAP
 
   m_mappedData = file->map(file->pos(), file->size() - file->pos());
   if(m_mappedData) {
     m_mappedFile = file;
     m_mappedDataSize = file->size() - file->pos();
     file->close(); //Close the file, so there is less open file descriptors(May be problematic)
   }else{
     qCDebug(LANGUAGE) << "Failed to map" << file->fileName();
   }
 
 #endif
 
   if(!m_mappedFile) {
     QByteArray data = file->readAll();
     m_data.append({data, (uint)data.size()});
     delete file;
   }
 
   m_dataLoaded = true;
 }
 
 TopDUContext* TopDUContextDynamicData::load(uint topContextIndex) {
   QFile file(pathForTopContext(topContextIndex));
   if(file.open(QIODevice::ReadOnly)) {
     if(file.size() == 0) {
       qCWarning(LANGUAGE) << "Top-context file is empty" << file.fileName();
       return nullptr;
     }
 
     uint readValue;
     file.read((char*)&readValue, sizeof(uint));
     //now readValue is filled with the top-context data size
     QByteArray topContextData = file.read(readValue);
 
     DUChainBaseData* topData = reinterpret_cast<DUChainBaseData*>(topContextData.data());
     TopDUContext* ret = dynamic_cast<TopDUContext*>(DUChainItemSystem::self().create(topData));
     if(!ret) {
       qCWarning(LANGUAGE) << "Cannot load a top-context from file" << file.fileName() << "- the required language-support for handling ID" << topData->classId << "is probably not loaded";
       return nullptr;
     }
 
     TopDUContextDynamicData& target(*ret->m_dynamicData);
 
     target.m_data.clear();
     target.m_dataLoaded = false;
     target.m_onDisk = true;
     ret->rebuildDynamicData(nullptr, topContextIndex);
     target.m_topContextData.append({topContextData, (uint)0});
     return ret;
   }else{
     return nullptr;
   }
 }
 
 bool TopDUContextDynamicData::isOnDisk() const {
   return m_onDisk;
 }
 
 void TopDUContextDynamicData::deleteOnDisk() {
   if(!isOnDisk())
     return;
   qCDebug(LANGUAGE) << "deleting" << m_topContext->ownIndex() << m_topContext->url().str();
 
   if(!m_dataLoaded)
     loadData();
 
   m_contexts.deleteOnDisk();
   m_declarations.deleteOnDisk();
   m_problems.deleteOnDisk();
 
   m_topContext->makeDynamic();
 
   m_onDisk = false;
 
   bool successfullyRemoved = QFile::remove(filePath());
   Q_UNUSED(successfullyRemoved);
   Q_ASSERT(successfullyRemoved);
   qCDebug(LANGUAGE) << "deletion ready";
 }
 
 QString KDevelop::TopDUContextDynamicData::filePath() const {
   return pathForTopContext(m_topContext->ownIndex());
 }
 
 bool TopDUContextDynamicData::hasChanged() const
 {
   return !m_onDisk || m_topContext->d_func()->m_dynamic
         || m_contexts.itemsHaveChanged() || m_declarations.itemsHaveChanged()
         || m_problems.itemsHaveChanged();
 }
 
 void TopDUContextDynamicData::store() {
 //   qCDebug(LANGUAGE) << "storing" << m_topContext->url().str() << m_topContext->ownIndex() << "import-count:" << m_topContext->importedParentContexts().size();
 
   //Check if something has changed. If nothing has changed, don't store to disk.
   bool contentDataChanged = hasChanged();
   if (!contentDataChanged) {
     return;
   }
 
   ///@todo Save the meta-data into a repository, and only the actual content data into a file.
   ///      This will make saving+loading more efficient, and will reduce the disk-usage.
   ///      Then we also won't need to load the data if only the meta-data changed.
   if(!m_dataLoaded)
     loadData();
 
   ///If the data is mapped, and we re-write the file, we must make sure that the data is copied out of the map,
   ///even if only metadata is changed.
   ///@todo If we split up data and metadata, we don't need to do this
   if(m_mappedData)
     contentDataChanged = true;
 
   m_topContext->makeDynamic();
   m_topContextData.clear();
   Q_ASSERT(m_topContext->d_func()->m_ownIndex == m_topContext->ownIndex());
 
   uint topContextDataSize = DUChainItemSystem::self().dynamicSize(*m_topContext->d_func());
   m_topContextData.append({QByteArray(DUChainItemSystem::self().dynamicSize(*m_topContext->d_func()), topContextDataSize), 0u});
   uint actualTopContextDataSize = 0;
 
   if (contentDataChanged) {
     //We don't need these structures any more, since we have loaded all the declarations/contexts, and m_data
     //will be reset which these structures pointed into
     //Load all lazy declarations/contexts
 
     const auto oldData = m_data; //Keep the old data alive until everything is stored into a new data structure
 
     m_data.clear();
 
     uint newDataSize = 0;
     for (const ArrayWithPosition& array : oldData) {
         newDataSize += array.position;
     }
 
     newDataSize = std::max(newDataSize, 10000u);
 
     //We always put 1 byte to the front, so we don't have zero data-offsets, since those are used for "invalid".
     uint currentDataOffset = 1;
     m_data.append({QByteArray(newDataSize, 0), currentDataOffset});
 
     m_itemRetrievalForbidden = true;
 
     m_contexts.storeData(currentDataOffset, oldData);
     m_declarations.storeData(currentDataOffset, oldData);
     m_problems.storeData(currentDataOffset, oldData);
 
     m_itemRetrievalForbidden = false;
   }
 
     saveDUChainItem(m_topContextData, *m_topContext, actualTopContextDataSize, false);
     Q_ASSERT(actualTopContextDataSize == topContextDataSize);
     Q_ASSERT(m_topContextData.size() == 1);
     Q_ASSERT(!m_topContext->d_func()->isDynamic());
 
     unmap();
 
     QDir().mkpath(basePath());
 
     QFile file(filePath());
     if(file.open(QIODevice::WriteOnly)) {
 
       file.resize(0);
 
       file.write((char*)&topContextDataSize, sizeof(uint));
       foreach(const ArrayWithPosition& pos, m_topContextData)
         file.write(pos.array.constData(), pos.position);
 
       m_contexts.writeData(&file);
       m_declarations.writeData(&file);
       m_problems.writeData(&file);
 
       foreach(const ArrayWithPosition& pos, m_data)
         file.write(pos.array.constData(), pos.position);
 
       m_onDisk = true;
 
       if (file.size() == 0) {
         qCWarning(LANGUAGE) << "Saving zero size top ducontext data";
       }
       file.close();
     } else {
       qCWarning(LANGUAGE) << "Cannot open top-context for writing";
     }
 //   qCDebug(LANGUAGE) << "stored" << m_topContext->url().str() << m_topContext->ownIndex() << "import-count:" << m_topContext->importedParentContexts().size();
 }
 
 TopDUContextDynamicData::ItemDataInfo TopDUContextDynamicData::writeDataInfo(const ItemDataInfo& info, const DUChainBaseData* data, uint& totalDataOffset) {
   ItemDataInfo ret(info);
   Q_ASSERT(info.dataOffset);
   const auto size = DUChainItemSystem::self().dynamicSize(*data);
   Q_ASSERT(size);
 
   if(m_data.back().array.size() - m_data.back().position < size) {
       //Create a new m_data item
       m_data.append({QByteArray(std::max(size, 10000u), 0), 0u});
   }
 
   ret.dataOffset = totalDataOffset;
 
   uint pos = m_data.back().position;
   m_data.back().position += size;
   totalDataOffset += size;
 
   auto target = reinterpret_cast<DUChainBaseData*>(m_data.back().array.data() + pos);
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 800)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #endif
   memcpy(target, data, size);
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 800)
 #pragma GCC diagnostic pop
 #endif
 
   verifyDataInfo(ret, m_data);
   return ret;
 }
 
 uint TopDUContextDynamicData::allocateDeclarationIndex(Declaration* decl, bool temporary)
 {
   return m_declarations.allocateItemIndex(decl, temporary);
 }
 
 uint TopDUContextDynamicData::allocateContextIndex(DUContext* context, bool temporary)
 {
   return m_contexts.allocateItemIndex(context, temporary);
 }
 
 uint TopDUContextDynamicData::allocateProblemIndex(const ProblemPointer& problem)
 {
   return m_problems.allocateItemIndex(problem, false);
 }
 
 bool TopDUContextDynamicData::isDeclarationForIndexLoaded(uint index) const
 {
   return m_declarations.isItemForIndexLoaded(index);
 }
 
 bool TopDUContextDynamicData::isContextForIndexLoaded(uint index) const {
   return m_contexts.isItemForIndexLoaded(index);
 }
 
 bool TopDUContextDynamicData::isTemporaryContextIndex(uint index) const {
   return !(index < (0x0fffffff/2));
 }
 
 bool TopDUContextDynamicData::isTemporaryDeclarationIndex(uint index) const {
   return !(index < (0x0fffffff/2));
 }
 
-DUContext* TopDUContextDynamicData::getContextForIndex(uint index) const
+DUContext* TopDUContextDynamicData::contextForIndex(uint index) const
 {
   if(!m_dataLoaded)
     loadData();
 
   if (index == 0) {
     return m_topContext;
   }
 
-  return m_contexts.getItemForIndex(index);
+  return m_contexts.itemForIndex(index);
 }
 
-Declaration* TopDUContextDynamicData::getDeclarationForIndex(uint index) const
+Declaration* TopDUContextDynamicData::declarationForIndex(uint index) const
 {
   if(!m_dataLoaded)
     loadData();
 
-  return m_declarations.getItemForIndex(index);
+  return m_declarations.itemForIndex(index);
 }
 
-ProblemPointer TopDUContextDynamicData::getProblemForIndex(uint index) const
+ProblemPointer TopDUContextDynamicData::problemForIndex(uint index) const
 {
   if(!m_dataLoaded)
     loadData();
 
-  return m_problems.getItemForIndex(index);
+  return m_problems.itemForIndex(index);
 }
 
 void TopDUContextDynamicData::clearDeclarationIndex(Declaration* decl)
 {
   m_declarations.clearItemIndex(decl, decl->m_indexInTopContext);
 }
 
 void TopDUContextDynamicData::clearContextIndex(DUContext* context)
 {
   m_contexts.clearItemIndex(context, context->m_dynamicData->m_indexInTopContext);
 }
 
 void TopDUContextDynamicData::clearProblems()
 {
   m_problems.clearItems();
 }
diff --git a/kdevplatform/language/duchain/topducontextdynamicdata.h b/kdevplatform/language/duchain/topducontextdynamicdata.h
index c2cc8eb39c..615a0f8a99 100644
--- a/kdevplatform/language/duchain/topducontextdynamicdata.h
+++ b/kdevplatform/language/duchain/topducontextdynamicdata.h
@@ -1,187 +1,187 @@
 /* This is part of KDevelop
     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 KDEVPLATFORM_TOPDUCONTEXTDYNAMICDATA_H
 #define KDEVPLATFORM_TOPDUCONTEXTDYNAMICDATA_H
 
 #include <QVector>
 #include <QByteArray>
 #include "problem.h"
 
 class QFile;
 
 namespace KDevelop {
 
 class TopDUContext;
 class DUContext;
 class Declaration;
 class IndexedString;
 class IndexedDUContext;
 class DUChainBaseData;
 
 ///This class contains dynamic data of a top-context, and also the repository that contains all the data within this top-context.
 class TopDUContextDynamicData {
   public:
   explicit TopDUContextDynamicData(TopDUContext* topContext);
   ~TopDUContextDynamicData();
 
   void clear();
 
   /**
    * Allocates an index for the given declaration in this top-context.
    * The returned index is never zero.
    * @param temporary whether the declaration is temporary. If it is, it will be stored separately, not stored to disk,
    *                   and a duchain write-lock is not needed. Else, you need a write-lock when calling this.
   */
   uint allocateDeclarationIndex(Declaration* decl, bool temporary);
   
-  Declaration* getDeclarationForIndex(uint index) const;
+  Declaration* declarationForIndex(uint index) const;
   
   bool isDeclarationForIndexLoaded(uint index) const;
   
   void clearDeclarationIndex(Declaration* decl);
 
   /**
    * Allocates an index for the given context in this top-context.
    * The returned index is never zero.
    * @param temporary whether the context is temporary. If it is, it will be stored separately, not stored to disk,
    *                   and a duchain write-lock is not needed. Else, you need a write-lock when calling this.
   */
   uint allocateContextIndex(DUContext* ctx, bool temporary);
 
-  DUContext* getContextForIndex(uint index) const;
+  DUContext* contextForIndex(uint index) const;
 
   bool isContextForIndexLoaded(uint index) const;
 
   void clearContextIndex(DUContext* ctx);
 
 
   /**
    * Allocates an index for the given problem in this top-context.
    * The returned index is never zero.
    */
   uint allocateProblemIndex(const ProblemPointer& problem);
-  ProblemPointer getProblemForIndex(uint index) const;
+  ProblemPointer problemForIndex(uint index) const;
   void clearProblems();
 
   ///Stores this top-context to disk
   void store();
   
   ///Stores all remainings of this top-context that are on disk. The top-context will be fully dynamic after this.
   void deleteOnDisk();
   
   ///Whether this top-context is on disk(Either has been loaded, or has been stored)
   bool isOnDisk() const;
   
   ///Loads the top-context from disk, or returns zero on failure. The top-context will not be registered anywhere, and will have no ParsingEnvironmentFile assigned.
   ///Also loads all imported contexts. The Declarations/Contexts will be correctly initialized, and put into the symbol tables if needed.
   static TopDUContext* load(uint topContextIndex);
 
   ///Loads only the url out of the data stored on disk for the top-context.
   static IndexedString loadUrl(uint topContextIndex);
 
   static bool fileExists(uint topContextIndex);
   
   ///Loads only the list of importers out of the data stored on disk for the top-context.
   static QList<IndexedDUContext> loadImporters(uint topContextIndex);
   
   static QList<IndexedDUContext> loadImports(uint topContextIndex);
 
   bool isTemporaryContextIndex(uint index) const;
   bool isTemporaryDeclarationIndex(uint index) const ;
   
   bool m_deleting; ///Flag used during destruction
 
   struct ItemDataInfo {
     uint dataOffset; /// Offset of the data
     uint parentContext; /// Parent context of the data (0 means the global context)
   };
 
   struct ArrayWithPosition
   {
     QByteArray array;
     uint position;
   };
 
   private:
     bool hasChanged() const;
 
     void unmap();
     //Converts away from an mmap opened file to a data array
     
     QString filePath() const;
 
     void loadData() const;
 
     const char* pointerInData(uint offset) const;
 
     ItemDataInfo writeDataInfo(const ItemDataInfo& info, const DUChainBaseData* data, uint& totalDataOffset);
 
     TopDUContext* m_topContext;
 
     template<class Item>
     struct DUChainItemStorage
     {
       explicit DUChainItemStorage(TopDUContextDynamicData* data);
       ~DUChainItemStorage();
 
       void clearItems();
       bool itemsHaveChanged() const;
 
       void storeData(uint& currentDataOffset, const QVector<ArrayWithPosition>& oldData);
-      Item getItemForIndex(uint index) const;
+      Item itemForIndex(uint index) const;
 
       void clearItemIndex(const Item& item, const uint index);
 
       uint allocateItemIndex(const Item& item, const bool temporary);
 
       void deleteOnDisk();
       bool isItemForIndexLoaded(uint index) const;
 
       void loadData(QFile* file) const;
       void writeData(QFile* file);
 
       //May contain zero items if they were deleted
       mutable QVector<Item> items;
       mutable QVector<ItemDataInfo> offsets;
       QVector<Item> temporaryItems;
       TopDUContextDynamicData* const data;
     };
 
     DUChainItemStorage<DUContext*> m_contexts;
     DUChainItemStorage<Declaration*> m_declarations;
     DUChainItemStorage<ProblemPointer> m_problems;
 
     //For temporary declarations that will not be stored to disk, like template instantiations
 
     mutable QVector<ArrayWithPosition> m_data;
     mutable QVector<ArrayWithPosition> m_topContextData;
     bool m_onDisk;
     mutable bool m_dataLoaded;
 
     mutable QFile* m_mappedFile;
     mutable uchar* m_mappedData;
     mutable size_t m_mappedDataSize;
     mutable bool m_itemRetrievalForbidden;
 };
 }
 
 Q_DECLARE_TYPEINFO(KDevelop::TopDUContextDynamicData::ItemDataInfo, Q_PRIMITIVE_TYPE);
 Q_DECLARE_TYPEINFO(KDevelop::TopDUContextDynamicData::ArrayWithPosition, Q_MOVABLE_TYPE);
 
 #endif
diff --git a/kdevplatform/language/duchain/types/identifiedtype.cpp b/kdevplatform/language/duchain/types/identifiedtype.cpp
index cfa368de53..0acd707e77 100644
--- a/kdevplatform/language/duchain/types/identifiedtype.cpp
+++ b/kdevplatform/language/duchain/types/identifiedtype.cpp
@@ -1,96 +1,96 @@
 /* This file is part of KDevelop
     Copyright 2002-2005 Roberto Raggi <roberto@kdevelop.org>
     Copyright 2006 Adam Treat <treat@kde.org>
     Copyright 2006 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 "identifiedtype.h"
 #include "../declaration.h"
 #include "../duchainpointer.h"
 #include "../declarationid.h"
 #include <debug.h>
 
 namespace KDevelop
 {
 
 IdentifiedType::~IdentifiedType()
 {
 }
 
 void IdentifiedType::clear() {
   idData()->m_id = DeclarationId();
 }
 
 bool IdentifiedType::equals(const IdentifiedType* rhs) const
 {
   bool ret = false;
   if( idData()->m_id == rhs->idData()->m_id )
     ret = true;
 
   //qCDebug(LANGUAGE) << this << rhs << true;
   return ret;
 }
 
 // QualifiedIdentifier IdentifiedType::identifier() const
 // {
 //   return idData()->m_id ? idData()->m_iidData()->qualifiedIdentifier() : QualifiedIdentifier();
 // }
 
 QualifiedIdentifier IdentifiedType::qualifiedIdentifier() const {
   return idData()->m_id.qualifiedIdentifier();
 }
 
 uint IdentifiedType::hash() const {
   return idData()->m_id.hash();
 }
 
 DeclarationId IdentifiedType::declarationId() const {
   return idData()->m_id;
 }
 
 void IdentifiedType::setDeclarationId(const DeclarationId& id) {
   idData()->m_id = id;
 }
 
 Declaration* IdentifiedType::declaration(const TopDUContext* top) const
 {
-  return idData()->m_id.getDeclaration(top);
+  return idData()->m_id.declaration(top);
 }
 
 KDevelop::DUContext* IdentifiedType::internalContext(const KDevelop::TopDUContext* top) const {
   Declaration* decl = declaration(top);
   if(decl)
     return decl->internalContext();
   else
     return nullptr;
 }
 
 void IdentifiedType::setDeclaration(Declaration* declaration)
 {
   if(declaration)
     idData()->m_id = declaration->id();
   else
     idData()->m_id = DeclarationId();
 }
 
 // QString IdentifiedType::idMangled() const
 // {
 //   return identifier().mangled();
 // }
 
 }
diff --git a/kdevplatform/language/util/basicsetrepository.h b/kdevplatform/language/util/basicsetrepository.h
index 21c959e55c..57e0146514 100644
--- a/kdevplatform/language/util/basicsetrepository.h
+++ b/kdevplatform/language/util/basicsetrepository.h
@@ -1,349 +1,349 @@
 /***************************************************************************
    Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KDEVPLATFORM_BASICSETREPOSITORY_H
 #define KDEVPLATFORM_BASICSETREPOSITORY_H
 
 #include <set>
 #include <vector>
 #include <language/languageexport.h>
 #include <language/util/kdevhash.h>
 #include <serialization/itemrepository.h>
 
 /**
  * This file provides a set system that can be used to efficiently manage sub-sets of a set of global objects.
  * Each global object must be mapped to a natural number.
  *
  * The efficiency comes from:
  * 1. The sets are represented by binary trees, where every single tree node can be shared across multiple sets.
  *    For that reason, intersecting sets will share large parts of their internal data structures, which leads to
  *    extremely low memory-usage compared to using for example std::set.
  *
  * The more common intersections between the sets exist, the more efficient the system is.
  * This will have the biggest advantage when items that were added contiguously are commonly
  * used within the same sets, and work fastest if the intersections between different sets are contiguously long.
  *
  * That makes it perfect for representing sets that are inherited across tree-like structures, like for example in C++:
  * - Macros defined in files(Macros are inherited from included files)
  * - Strings contained in files(Strings are inherited from included files)
  * - Set of all included files
  *
  * Measurements(see in kdevelop languages/cpp/cppduchain/tests/duchaintest) show that even in worst case(with totally random sets)
  * these set-repositories are 2 times faster than std::set, and 4 times faster than QSet.
  *
  * The main disadvantages are that a global repository needs to be managed, and needs to be secured from simultaneous write-access
  * during multi-threading. This is done internally if the doLocking flag is set while constructing.
  * */
 
 class QString;
 
 namespace Utils {
 
 enum {
 delayedDeletionByDefault = 0
 };
 
 class SetNode;
 class BasicSetRepository;
 class SetNodeDataRequest;
 
 ///Internal node representation, exported here for performance reason.
 struct KDEVPLATFORMLANGUAGE_EXPORT SetNodeData {
 private:
   //Rule: start < end
   uint m_start, m_end; //This set-node bounds all indices starting at start until end, not including end.
 
   //Child nodes
   //Rule: left->start == start, right->end == end
   //Rule: (left != 0 && right != 0) || (left == 0 && right == 0)
   uint m_leftNode, m_rightNode;
 
   // cached hash of this node data - it only includes the first four data members,
   // i.e. m_start, m_end, m_leftNode and m_rightNode
   uint m_hash;
 public:
   uint m_refCount = 0;
 
   inline explicit SetNodeData(uint start = 1, uint end = 1, uint leftNode = 0, uint rightNode = 0)
   : m_start(start)
   , m_end(end)
   , m_leftNode(leftNode)
   , m_rightNode(rightNode)
   , m_hash(calculateHash())
   {
   }
 
   inline uint hash() const
   {
     return m_hash;
   }
 
   uint calculateHash() const
   {
       return KDevHash() << m_start << m_end << m_leftNode << m_rightNode;
   }
 
   inline short unsigned int itemSize() const {
     return sizeof(SetNodeData);
   }
 
   inline bool contiguous() const {
     return !m_leftNode;
   }
 
   inline bool hasSlaves() const {
     return (bool)m_leftNode;
   }
 
   inline uint start() const
   {
     return m_start;
   }
   inline uint end() const
   {
     return m_end;
   }
   inline uint leftNode() const
   {
     return m_leftNode;
   }
   inline uint rightNode() const
   {
     return m_rightNode;
   }
 };
 
 typedef KDevelop::ItemRepository<SetNodeData, SetNodeDataRequest, false, false, sizeof(SetNodeData)> SetDataRepositoryBase;
 
 struct SetDataRepository;
 
 class SetNodeDataRequest {
 public:
 
   enum {
     AverageSize = sizeof(SetNodeData)
   };
   
   //This constructor creates a request that finds or creates a node that equals the given node
   //The m_hash must be up to date, and the node must be split correctly around its splitPosition
   inline SetNodeDataRequest(const SetNodeData* _data, SetDataRepository& _repository, BasicSetRepository* _setRepository);
   
   ~SetNodeDataRequest();
 
   typedef unsigned int HashType;
   
   //Should return the m_hash-value associated with this request(For example the m_hash of a string)
   inline HashType hash() const {
     return m_hash;
   }
   
   //Should return the size of an item created with createItem
   inline uint itemSize() const {
       return sizeof(SetNodeData);
   }
   //Should create an item where the information of the requested item is permanently stored. The pointer
   //@param item equals an allocated range with the size of itemSize().
   void createItem(SetNodeData* item) const;
   
   static void destroy(SetNodeData* data, KDevelop::AbstractItemRepository& _repository);
 
   static bool persistent(const SetNodeData* item) {
       return (bool)item->m_refCount;
   }
 
   //Should return whether the here requested item equals the given item
   bool equals(const SetNodeData* item) const;
   
   SetNodeData data;
   
   uint m_hash;
   SetDataRepository& repository;
   mutable BasicSetRepository* setRepository; //May be zero when no notifications are wanted
   mutable bool m_created;
 };
 
 struct KDEVPLATFORMLANGUAGE_EXPORT SetDataRepository : public SetDataRepositoryBase {
   SetDataRepository(BasicSetRepository* _setRepository, const QString& name, KDevelop::ItemRepositoryRegistry* registry) : SetDataRepositoryBase(name, registry), setRepository(_setRepository) {
   }
   
   BasicSetRepository* setRepository;
 };
 
 /**
  * This object is copyable. It represents a set, and allows iterating through the represented indices.
  * */
 class KDEVPLATFORMLANGUAGE_EXPORT Set {
 public:
   class Iterator;
   typedef unsigned int Index;
   
   Set();
   //Internal constructor
   Set(uint treeNode, BasicSetRepository* repository);
   ~Set();
   Set(const Set& rhs);
   Set& operator=(const Set& rhs);
 
   QString dumpDotGraph() const;
 
   //Returns an itrator that can be used to iterate over the contained indices
   Iterator iterator() const;
 
   //Returns this set converted to a standard set that contains all indices contained by this set.
   std::set<unsigned int> stdSet() const;
 
   ///Returns the count of items in the set
   unsigned int count() const;
 
   bool contains(Index index) const;
   
   ///@warning: The following operations can change the global repository, and thus need to be serialized
   ///          using mutexes in case of multi-threading.
 
   ///Set union
   Set operator +(const Set& rhs) const;
   Set& operator +=(const Set& rhs);
   
   ///Set intersection
   Set operator &(const Set& rhs) const;
   Set& operator &=(const Set& rhs);
 
   ///Set subtraction
   Set operator -(const Set& rhs) const;
   Set& operator -=(const Set& rhs);
   
   uint setIndex() const {
     return m_tree;
   }
   
     ///Increase the static reference-count of this set by one. The initial reference-count of newly created sets is zero.
     void staticRef();
     
     ///Decrease the static reference-count of this set by one. This set must have a reference-count >= 1.
     ///If this set reaches the reference-count zero, it will be deleted, and all sub-nodes that also reach the reference-count zero
     ///will be deleted as well. @warning Either protect ALL your sets by using reference-counting, or don't use it at all.
     void staticUnref();
   
   ///Returns a pointer to the repository this set belongs to. Returns zero when this set is not initialized yet.
   BasicSetRepository* repository() const;
 private:
   void unrefNode(uint);
   friend class BasicSetRepository;
   
   uint m_tree = 0;
   mutable BasicSetRepository* m_repository = nullptr;
 };
 
 /**
  * This is a repository that can be used to efficiently manage generic sets
  * that are represented by interweaved binary trees.
  *
  * All strings are based on items that are contained in one master-repository,
  * starting at one.
  *
  * An index of zero is interpreted as invalid.
  * */
 
 class KDEVPLATFORMLANGUAGE_EXPORT BasicSetRepository {
 public:
   ///@param name The name must be unique, and is used for loading and storing the data
   ///@param registry Where the repository should be registered. If you give zero, it won't be registered, and thus won't be saved to disk.
   explicit BasicSetRepository(const QString& name, KDevelop::ItemRepositoryRegistry* registry = &KDevelop::globalItemRepositoryRegistry(), bool delayedDeletion = delayedDeletionByDefault);
   virtual ~BasicSetRepository();
   typedef unsigned int Index;
 
   /**
    * Takes a sorted list indices, returns a set representing them
    * */
   Set createSetFromIndices(const std::vector<Index>& indices);
 
   /**
    * Takes a simple set of indices
    * */
   Set createSet(const std::set<Index>& indices);
 
   /**
    * Creates a set that only contains that single index.
    * For better performance, you should create bigger sets than this.
    * */
   Set createSet(Index i);
   
   void printStatistics() const;
   
   ///Is called when this index is not part of any set any more
   virtual void itemRemovedFromSets(uint index);
   
   ///Is called when this index is added to one of the contained sets for the first time
   virtual void itemAddedToSets(uint index);
   
   inline const SetNodeData* nodeFromIndex(uint index) const {
       if(index)
-          return dataRepository.itemFromIndex(index);
+          return m_dataRepository.itemFromIndex(index);
       else
           return nullptr;
   }
   
   inline QMutex* mutex() const {
       return m_mutex;
   }
   
   ///Only public to get statistics and such
-  const SetDataRepository& getDataRepository() const {
-      return dataRepository;
+  const SetDataRepository& dataRepository() const {
+      return m_dataRepository;
   }
   
   ///Set whether set-nodes with reference-count zero should be deleted only after a delay
   ///The default is true.
   ///This may be faster when the structure is large anyway and many temporary sets
   ///are created, but leads to a sparse structure in memory, which is bad for cache.
   void setDelayedDeletion(bool delayed) {
     m_delayedDeletion = delayed;
   }
   
   inline bool delayedDeletion() const {
     return m_delayedDeletion;
   }
   
 private:
   friend class Set;
   friend class Set::Iterator;
-  SetDataRepository dataRepository;
+  SetDataRepository m_dataRepository;
   QMutex* m_mutex;
   bool m_delayedDeletion;
   
 //   SetNode
 };
 
 /**
  * Use this to iterate over the indices contained in a set
  * */
 class KDEVPLATFORMLANGUAGE_EXPORT Set::Iterator {
 public:
   Iterator();
   Iterator(const Iterator& rhs);
   Iterator& operator=(const Iterator& rhs);
   
   ~Iterator();
   operator bool() const;
   Iterator& operator++();
   BasicSetRepository::Index operator*() const;
 private:
   friend class Set;
   friend class SetIteratorPrivate;
-  static inline SetDataRepository &getDataRepository(BasicSetRepository *repo) { return repo->dataRepository; }
+  static inline SetDataRepository &getDataRepository(BasicSetRepository *repo) { return repo->m_dataRepository; }
   const QScopedPointer<class SetIteratorPrivate> d;
 };
 
 }
 
 #endif
diff --git a/kdevplatform/language/util/setrepository.cpp b/kdevplatform/language/util/setrepository.cpp
index 5c66193889..6190376d70 100644
--- a/kdevplatform/language/util/setrepository.cpp
+++ b/kdevplatform/language/util/setrepository.cpp
@@ -1,1129 +1,1129 @@
 /***************************************************************************
    Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "setrepository.h"
 #include <debug.h>
 #include <list>
 #include <util/kdevvarlengtharray.h>
 #include <iostream>
 #include <limits>
 #include <serialization/itemrepository.h>
 #include <serialization/indexedstring.h>
 #include <QString>
 #include <QMutex>
 #include <algorithm>
 
 //#define DEBUG_SETREPOSITORY
 
 #ifdef DEBUG_SETREPOSITORY
 #define ifDebug(X) X
 #else
 #define ifDebug(x)
 #undef Q_ASSERT
 #define Q_ASSERT(x)
 #endif
 
 #ifndef DEBUG_SETREPOSITORY
 #define CHECK_SPLIT_POSITION(Node)
 #else
 #define CHECK_SPLIT_POSITION(node) Q_ASSERT(!(node).leftNode || (getLeftNode(&node)->end() <= splitPositionForRange((node).start, (node).end) && getRightNode(&node)->start() >= splitPositionForRange((node).start, (node).end)))
 #endif
 
 namespace Utils {
 
 /**
  * To achieve a maximum re-usage of nodes, we make sure that sub-nodes of a node always split at specific boundaries.
  * For each range we can compute a position where that range should be split into its child-nodes.
  * When creating a new node with 2 sub-nodes, we re-create those child-nodes if their boundaries don't represent those split-positions.
  *
  * We pick the split-positions deterministically, they are in order of priority:
  * ((1<<31)*n, n = [0,...]
  * ((1<<30)*n, n = [0,...]
  * ((1<<29)*n, n = [0,...]
  * ((1<<...)*n, n = [0,...]
  * ...
  * */
 
 
 typedef BasicSetRepository::Index Index;
 
 ///The returned split position shall be the end of the first sub-range, and the start of the second
 ///@param splitBit should be initialized with 31, unless you know better. The value can then be used on while computing child split positions.
 ///In the end, it will contain the bit used to split the range. It will also contain zero if no split-position exists(length 1)
 uint splitPositionForRange(uint start, uint end, uchar& splitBit) {
 
   if(end-start == 1) {
     splitBit = 0;
     return 0;
   }
 
   while(true) {
     uint position = ((end-1) >> splitBit) << splitBit; //Round to the split-position in this interval that is smaller than end
     if(position > start && position < end)
       return position;
     Q_ASSERT(splitBit != 0);
     --splitBit;
   }
 
   return 0;
 }
 
 uint splitPositionForRange(uint start, uint end) {
   uchar splitBit = 31;
   return splitPositionForRange(start, end, splitBit);
 }
 
 class SetNodeDataRequest;
 
     #define getLeftNode(node) repository.itemFromIndex(node->leftNode())
     #define getRightNode(node) repository.itemFromIndex(node->rightNode())
     #define nodeFromIndex(index) repository.itemFromIndex(index)
 struct SetRepositoryAlgorithms {
   SetRepositoryAlgorithms(SetDataRepository& _repository, BasicSetRepository* _setRepository) : repository(_repository), setRepository(_setRepository) {
   }
 
   ///Expensive
   Index count(const SetNodeData* node) const;
 
   void localCheck(const SetNodeData* node);
 
   void check(uint node);
 
   void check(const SetNodeData* node);
 
   QString shortLabel(const SetNodeData& node) const;
 
   uint set_union(uint firstNode, uint secondNode, const SetNodeData* first, const SetNodeData* second, uchar splitBit = 31);
   uint createSetFromNodes(uint leftNode, uint rightNode, const SetNodeData* left = nullptr, const SetNodeData* right = nullptr);
   uint computeSetFromNodes(uint leftNode, uint rightNode, const SetNodeData* left, const SetNodeData* right, uchar splitBit);
   uint set_intersect(uint firstNode, uint secondNode, const SetNodeData* first, const SetNodeData* second, uchar splitBit = 31);
   bool set_contains(const SetNodeData* node, Index index);
   uint set_subtract(uint firstNode, uint secondNode, const SetNodeData* first, const SetNodeData* second, uchar splitBit = 31);
 
   //Required both nodes to be split correctly
   bool set_equals(const SetNodeData* lhs, const SetNodeData* rhs);
 
   QString dumpDotGraph(uint node) const;
 
     ///Finds or inserts the given ranges into the repository, and returns the set-index that represents them
     uint setForIndices(std::vector<uint>::const_iterator begin, std::vector<uint>::const_iterator end, uchar splitBit = 31) {
         Q_ASSERT(begin != end);
 
         uint startIndex = *begin;
         uint endIndex = *(end-1)+1;
 
         if(endIndex == startIndex+1) {
             SetNodeData data(startIndex, endIndex);
 
             return repository.index( SetNodeDataRequest(&data, repository, setRepository) );
         }
 
         uint split = splitPositionForRange(startIndex, endIndex, splitBit);
         Q_ASSERT(split);
 
         std::vector<uint>::const_iterator splitIterator = std::lower_bound(begin, end, split);
         Q_ASSERT(*splitIterator >= split);
         Q_ASSERT(splitIterator > begin);
         Q_ASSERT(*(splitIterator-1) < split);
 
         return createSetFromNodes(setForIndices(begin, splitIterator, splitBit), setForIndices(splitIterator, end, splitBit));
     }
 
 
 private:
   QString dumpDotGraphInternal(uint node, bool master=false) const;
 
   SetDataRepository& repository;
   BasicSetRepository* setRepository;
 };
 
 void SetNodeDataRequest::destroy(SetNodeData* data, KDevelop::AbstractItemRepository& _repository) {
     SetDataRepository& repository(static_cast<SetDataRepository&>(_repository));
 
     if(repository.setRepository->delayedDeletion()) {
 
         if(data->leftNode()){
             SetDataRepositoryBase::MyDynamicItem left = repository.dynamicItemFromIndex(data->leftNode());
             SetDataRepositoryBase::MyDynamicItem right = repository.dynamicItemFromIndex(data->rightNode());
             Q_ASSERT(left->m_refCount > 0);
             --left->m_refCount;
             Q_ASSERT(right->m_refCount > 0);
             --right->m_refCount;
         }else {
             //Deleting a leaf
             Q_ASSERT(data->end() - data->start() == 1);
             repository.setRepository->itemRemovedFromSets(data->start());
         }
     }
 }
 
 SetNodeDataRequest::SetNodeDataRequest(const SetNodeData* _data, SetDataRepository& _repository, BasicSetRepository* _setRepository) : data(*_data), m_hash(_data->hash()), repository(_repository), setRepository(_setRepository), m_created(false) {
     ifDebug( SetRepositoryAlgorithms alg(repository); alg.check(_data) );
 }
 
 SetNodeDataRequest::~SetNodeDataRequest() {
     //Eventually increase the reference-count of direct children
     if(m_created) {
         if(data.leftNode())
         ++repository.dynamicItemFromIndex(data.leftNode())->m_refCount;
         if(data.rightNode())
         ++repository.dynamicItemFromIndex(data.rightNode())->m_refCount;
     }
 }
 
 //Should create an item where the information of the requested item is permanently stored. The pointer
 //@param item equals an allocated range with the size of itemSize().
 void SetNodeDataRequest::createItem(SetNodeData* item) const {
     Q_ASSERT((data.rightNode() && data.leftNode()) || (!data.rightNode() && !data.leftNode()));
 
     m_created = true;
 
     *item = data;
 
     Q_ASSERT((item->rightNode() && item->leftNode()) || (!item->rightNode() && !item->leftNode()));
 
 #ifdef DEBUG_SETREPOSITORY
     //Make sure we split at the correct split position
     if(item->hasSlaves()) {
         uint split = splitPositionForRange(data.start, data.end);
         const SetNodeData* left = repository.itemFromIndex(item->leftNode());
         const SetNodeData* right = repository.itemFromIndex(item->rightNode());
         Q_ASSERT(split >= left->end() && split <= right->start());
     }
 #endif
     if(!data.leftNode() && setRepository) {
         for(uint a = item->start(); a < item->end(); ++a)
             setRepository->itemAddedToSets(a);
     }
 }
 
 bool SetNodeDataRequest::equals(const SetNodeData* item) const {
     Q_ASSERT((item->rightNode() && item->leftNode()) || (!item->rightNode() && !item->leftNode()));
     //Just compare child nodes, since data must be correctly split, this is perfectly ok
     //Since this happens in very tight loops, we don't call an additional function here, but just do the check.
     return item->leftNode() == data.leftNode() && item->rightNode() == data.rightNode() && item->start() == data.start() && item->end() == data.end();
 }
 
 Set::Set() {
 }
 
 Set::~Set() {
 }
 
 unsigned int Set::count() const {
   if(!m_repository || !m_tree)
     return 0;
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
-  return alg.count(m_repository->dataRepository.itemFromIndex(m_tree));
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
+  return alg.count(m_repository->m_dataRepository.itemFromIndex(m_tree));
 }
 
 Set::Set(uint treeNode, BasicSetRepository* repository) : m_tree(treeNode), m_repository(repository) {
 }
 
 
 Set::Set(const Set& rhs) {
   m_repository = rhs.m_repository;
   m_tree = rhs.m_tree;
 }
 
 Set& Set::operator=(const Set& rhs) {
   m_repository = rhs.m_repository;
   m_tree = rhs.m_tree;
   return *this;
 }
 
 QString Set::dumpDotGraph() const {
   if(!m_repository || !m_tree)
     return QString();
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
   return alg.dumpDotGraph(m_tree);
 }
 
 Index SetRepositoryAlgorithms::count(const SetNodeData* node) const {
   if(node->leftNode() && node->rightNode())
     return count(getLeftNode(node)) + count(getRightNode(node));
   else
     return node->end() - node->start();
 }
 
 void SetRepositoryAlgorithms::localCheck(const SetNodeData* ifDebug(node) ) {
 //   Q_ASSERT(node->start() > 0);
   Q_ASSERT(node->start() < node->end());
   Q_ASSERT((node->leftNode() && node->rightNode()) || (!node->leftNode() && !node->rightNode()));
   Q_ASSERT(!node->leftNode() || (getLeftNode(node())->start() == node->start() && getRightNode(node)->end() == node->end()));
   Q_ASSERT(!node->leftNode() || (getLeftNode(node())->end() <= getRightNode(node)->start()));
 }
 
 void SetRepositoryAlgorithms::check(uint node) {
   if(!node)
     return;
 
   check(nodeFromIndex(node));
 }
 
 void SetRepositoryAlgorithms::check(const SetNodeData* node) {
   localCheck(node);
   if(node->leftNode())
     check(getLeftNode(node));
   if(node->rightNode())
     check(getRightNode(node));
 //  CHECK_SPLIT_POSITION(*node); Re-enable this
 }
 
 QString SetRepositoryAlgorithms::shortLabel(const SetNodeData& node) const {
   return QStringLiteral("n%1_%2").arg(node.start()).arg(node.end());
 }
 
 QString SetRepositoryAlgorithms::dumpDotGraphInternal(uint nodeIndex, bool master) const {
   if(!nodeIndex)
     return QStringLiteral("empty node");
 
   const SetNodeData& node(*repository.itemFromIndex(nodeIndex));
 
   QString color = QStringLiteral("blue");
   if(master)
     color = QStringLiteral("red");
 
   QString label = QStringLiteral("%1 -> %2").arg(node.start()).arg(node.end());
   if(!node.contiguous())
     label += QLatin1String(", with gaps");
 
   QString ret = QStringLiteral("%1[label=\"%2\", color=\"%3\"];\n").arg(shortLabel(node), label, color);
 
   if(node.leftNode()) {
     const SetNodeData& left(*repository.itemFromIndex(node.leftNode()));
     const SetNodeData& right(*repository.itemFromIndex(node.rightNode()));
     Q_ASSERT(node.rightNode());
     ret += QStringLiteral("%1 -> %2;\n").arg(shortLabel(node), shortLabel(left));
     ret += QStringLiteral("%1 -> %2;\n").arg(shortLabel(node), shortLabel(right));
     ret += dumpDotGraphInternal(node.leftNode());
     ret += dumpDotGraphInternal(node.rightNode());
   }
 
   return ret;
 }
 
 QString SetRepositoryAlgorithms::dumpDotGraph(uint nodeIndex) const {
   QString ret = QStringLiteral("digraph Repository {\n");
   ret += dumpDotGraphInternal(nodeIndex, true);
   ret += QLatin1String("}\n");
   return ret;
 }
 
 const int nodeStackAlloc = 500;
 
 class SetIteratorPrivate
 {
 public:
   SetIteratorPrivate()
   {
     nodeStackData.resize(nodeStackAlloc);
     nodeStack = nodeStackData.data();
   }
 
   SetIteratorPrivate(const SetIteratorPrivate& rhs)
     : nodeStackData(rhs.nodeStackData)
     , nodeStackSize(rhs.nodeStackSize)
     , currentIndex(rhs.currentIndex)
     , repository(rhs.repository)
   {
     nodeStack = nodeStackData.data();
   }
 
   SetIteratorPrivate& operator=(const SetIteratorPrivate& rhs)
   {
     nodeStackData = rhs.nodeStackData;
     nodeStackSize = rhs.nodeStackSize;
     currentIndex = rhs.currentIndex;
     repository = rhs.repository;
     nodeStack = nodeStackData.data();
 
     return *this;
   }
 
   void resizeNodeStack() {
     nodeStackData.resize(nodeStackSize + 1);
     nodeStack = nodeStackData.data();
   }
 
   KDevVarLengthArray<const SetNodeData*, nodeStackAlloc> nodeStackData;
   const SetNodeData** nodeStack;
   int nodeStackSize = 0;
   Index currentIndex = 0;
   BasicSetRepository* repository = nullptr;
 
   /**
    * Pushes the noed on top of the stack, changes currentIndex, and goes as deep as necessary for iteration.
    * */
   void startAtNode(const SetNodeData* node) {
     Q_ASSERT(node->start() != node->end());
     currentIndex = node->start();
 
     do {
       nodeStack[nodeStackSize++] = node;
 
       if(nodeStackSize >= nodeStackAlloc)
           resizeNodeStack();
 
       if(node->contiguous())
         break; //We need no finer granularity, because the range is contiguous
       node = Set::Iterator::getDataRepository(repository).itemFromIndex(node->leftNode());
     } while(node);
     Q_ASSERT(currentIndex >= nodeStack[0]->start());
   }
 };
 
 
 std::set<Index> Set::stdSet() const
 {
   Set::Iterator it = iterator();
   std::set<Index> ret;
 
   while(it) {
     Q_ASSERT(ret.find(*it) == ret.end());
     ret.insert(*it);
     ++it;
   }
 
   return ret;
 }
 
 Set::Iterator::Iterator(const Iterator& rhs)
     : d(new SetIteratorPrivate(*rhs.d))
 {
 }
 
 Set::Iterator& Set::Iterator::operator=(const Iterator& rhs) {
   *d = *rhs.d;
   return *this;
 }
 
 Set::Iterator::Iterator()
     : d(new SetIteratorPrivate)
 {
 }
 
 Set::Iterator::~Iterator() = default;
 
 Set::Iterator::operator bool() const {
   return d->nodeStackSize;
 }
 
 Set::Iterator& Set::Iterator::operator++() {
 
   Q_ASSERT(d->nodeStackSize);
 
   if(d->repository->m_mutex)
     d->repository->m_mutex->lock();
 
   ++d->currentIndex;
 
   //const SetNodeData** currentNode = &d->nodeStack[d->nodeStackSize - 1];
   if(d->currentIndex >= d->nodeStack[d->nodeStackSize - 1]->end()) {
     //Advance to the next node
     while(d->nodeStackSize && d->currentIndex >= d->nodeStack[d->nodeStackSize - 1]->end()) {
       --d->nodeStackSize;
     }
 
     if(!d->nodeStackSize) {
       //ready
     }else{
       //++d->nodeStackSize;
       //We were iterating the left slave of the node, now continue with the right.
-      ifDebug( const SetNodeData& left = *d->repository->dataRepository.itemFromIndex(d->nodeStack[d->nodeStackSize - 1]->leftNode()); Q_ASSERT(left.end == d->currentIndex); )
+      ifDebug( const SetNodeData& left = *d->repository->m_dataRepository.itemFromIndex(d->nodeStack[d->nodeStackSize - 1]->leftNode()); Q_ASSERT(left.end == d->currentIndex); )
 
-      const SetNodeData& right = *d->repository->dataRepository.itemFromIndex(d->nodeStack[d->nodeStackSize - 1]->rightNode());
+      const SetNodeData& right = *d->repository->m_dataRepository.itemFromIndex(d->nodeStack[d->nodeStackSize - 1]->rightNode());
 
       d->startAtNode(&right);
     }
   }
 
   Q_ASSERT(d->nodeStackSize == 0 || d->currentIndex < d->nodeStack[0]->end());
 
   if(d->repository->m_mutex)
     d->repository->m_mutex->unlock();
 
   return *this;
 }
 
 BasicSetRepository::Index Set::Iterator::operator*() const {
   return d->currentIndex;
 }
 
 Set::Iterator Set::iterator() const {
   if(!m_tree || !m_repository)
     return Iterator();
 
   QMutexLocker lock(m_repository->m_mutex);
 
   Iterator ret;
   ret.d->repository = m_repository;
 
   if(m_tree)
-    ret.d->startAtNode(m_repository->dataRepository.itemFromIndex(m_tree));
+    ret.d->startAtNode(m_repository->m_dataRepository.itemFromIndex(m_tree));
   return ret;
 }
 
 //Creates a set item with the given children., they must be valid, and they must be split around their split-position.
 uint SetRepositoryAlgorithms::createSetFromNodes(uint leftNode, uint rightNode, const SetNodeData* left, const SetNodeData* right) {
 
     if(!left)
       left = nodeFromIndex(leftNode);
     if(!right)
       right = nodeFromIndex(rightNode);
 
     Q_ASSERT(left->end() <= right->start());
 
     SetNodeData set(left->start(), right->end(), leftNode, rightNode);
 
     Q_ASSERT(set.start() < set.end());
 
     uint ret = repository.index(SetNodeDataRequest(&set, repository, setRepository));
     Q_ASSERT(set.leftNode() >= 0x10000);
     Q_ASSERT(set.rightNode() >= 0x10000);
     Q_ASSERT(ret == repository.findIndex(SetNodeDataRequest(&set, repository, setRepository)));
     ifDebug( check(ret) );
     return ret;
 }
 
 //Constructs a set node from the given two sub-nodes. Those must be valid, they must not intersect, and they must have a correct split-hierarchy.
 //The do not need to be split around their computed split-position.
 uint SetRepositoryAlgorithms::computeSetFromNodes(uint leftNode, uint rightNode, const SetNodeData* left, const SetNodeData* right, uchar splitBit)
 {
   Q_ASSERT(left->end() <= right->start());
   uint splitPosition = splitPositionForRange(left->start(), right->end(), splitBit);
 
   Q_ASSERT(splitPosition);
 
   if(splitPosition < left->end()) {
     //The split-position intersects the left node
     uint leftLeftNode = left->leftNode();
     uint leftRightNode = left->rightNode();
 
     const SetNodeData* leftLeft = this->getLeftNode(left);
     const SetNodeData* leftRight = this->getRightNode(left);
 
     Q_ASSERT(splitPosition >= leftLeft->end() && splitPosition <= leftRight->start());
 
     //Create a new set from leftLeft, and from leftRight + right. That set will have the correct split-position.
     uint newRightNode = computeSetFromNodes(leftRightNode, rightNode, leftRight, right, splitBit);
 
     return createSetFromNodes(leftLeftNode, newRightNode, leftLeft);
 
   }else if(splitPosition > right->start()) {
     //The split-position intersects the right node
     uint rightLeftNode = right->leftNode();
     uint rightRightNode = right->rightNode();
 
     const SetNodeData* rightLeft = this->getLeftNode(right);
     const SetNodeData* rightRight = this->getRightNode(right);
 
     Q_ASSERT(splitPosition >= rightLeft->end() && splitPosition <= rightRight->start());
 
     //Create a new set from left + rightLeft, and from rightRight. That set will have the correct split-position.
     uint newLeftNode = computeSetFromNodes(leftNode, rightLeftNode, left, rightLeft, splitBit);
 
     return createSetFromNodes(newLeftNode, rightRightNode, nullptr, rightRight);
   }else{
     return createSetFromNodes(leftNode, rightNode, left, right);
   }
 }
 
 uint SetRepositoryAlgorithms::set_union(uint firstNode, uint secondNode, const SetNodeData* first, const SetNodeData* second, uchar splitBit)
 {
   if(firstNode == secondNode)
     return firstNode;
 
   uint firstStart = first->start(), secondEnd = second->end();
 
   if(firstStart >= secondEnd)
     return computeSetFromNodes(secondNode, firstNode, second, first, splitBit);
 
   uint firstEnd = first->end(), secondStart = second->start();
 
   if(secondStart >= firstEnd)
     return computeSetFromNodes(firstNode, secondNode, first, second, splitBit);
 
   //The ranges of first and second do intersect
 
   uint newStart = firstStart < secondStart ? firstStart : secondStart;
   uint newEnd = firstEnd > secondEnd ? firstEnd : secondEnd;
 
   //Compute the split-position for the resulting merged node
   uint splitPosition = splitPositionForRange(newStart, newEnd, splitBit);
 
   //Since the ranges overlap, we can be sure that either first or second contain splitPosition.
   //The node that contains it, will also be split by it.
 
   if(splitPosition > firstStart && splitPosition < firstEnd && splitPosition > secondStart && splitPosition < secondEnd) {
     //The split-position intersect with both first and second. Continue the union on both sides of the split-position, and merge it.
 
     uint firstLeftNode = first->leftNode();
     uint firstRightNode = first->rightNode();
     uint secondLeftNode = second->leftNode();
     uint secondRightNode = second->rightNode();
 
     const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
     const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
     const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
     const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);
 
     Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
     Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());
 
     return createSetFromNodes( set_union(firstLeftNode, secondLeftNode, firstLeft, secondLeft, splitBit), set_union(firstRightNode, secondRightNode, firstRight, secondRight, splitBit) );
 
   }else if(splitPosition > firstStart && splitPosition < firstEnd) {
 
     uint firstLeftNode = first->leftNode();
     uint firstRightNode = first->rightNode();
 
     const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
     const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
 
     Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
 
     //splitPosition does not intersect second. That means that second is completely on one side of it.
     //So we only need to union that side of first with second.
 
     if(secondEnd <= splitPosition) {
       return createSetFromNodes( set_union(firstLeftNode, secondNode, firstLeft, second, splitBit), firstRightNode, nullptr, firstRight );
     }else{
       Q_ASSERT(secondStart >= splitPosition);
       return createSetFromNodes( firstLeftNode, set_union(firstRightNode, secondNode, firstRight, second, splitBit), firstLeft );
     }
 
   }else if(splitPosition > secondStart && splitPosition < secondEnd) {
 
     uint secondLeftNode = second->leftNode();
     uint secondRightNode = second->rightNode();
 
     const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
     const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);
 
     Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());
 
     if(firstEnd <= splitPosition) {
       return createSetFromNodes( set_union(secondLeftNode, firstNode, secondLeft, first, splitBit), secondRightNode, nullptr, secondRight );
     }else{
       Q_ASSERT(firstStart >= splitPosition);
       return createSetFromNodes( secondLeftNode, set_union(secondRightNode, firstNode, secondRight, first, splitBit), secondLeft );
     }
 
   }else{
     //We would have stopped earlier of first and second don't intersect
     ifDebug( uint test = repository.findIndex(SetNodeDataRequest(first, repository, setRepository)); qCDebug(LANGUAGE) << "found index:" << test; )
     Q_ASSERT(0);
     return 0;
   }
 }
 
 bool SetRepositoryAlgorithms::set_equals(const SetNodeData* lhs, const SetNodeData* rhs)
 {
   if(lhs->leftNode() != rhs->leftNode() || lhs->rightNode() != rhs->rightNode())
     return false;
   else
     return true;
 }
 
 uint SetRepositoryAlgorithms::set_intersect(uint firstNode, uint secondNode, const SetNodeData* first, const SetNodeData* second, uchar splitBit)
 {
   if(firstNode == secondNode)
     return firstNode;
 
   if(first->start() >= second->end())
     return 0;
 
   if(second->start() >= first->end())
     return 0;
 
   //The ranges of first and second do intersect
   uint firstStart = first->start(), firstEnd = first->end(), secondStart = second->start(), secondEnd = second->end();
 
   uint newStart = firstStart < secondStart ? firstStart : secondStart;
   uint newEnd = firstEnd > secondEnd ? firstEnd : secondEnd;
 
   //Compute the split-position for the resulting merged node
   uint splitPosition = splitPositionForRange(newStart, newEnd, splitBit);
 
   //Since the ranges overlap, we can be sure that either first or second contain splitPosition.
   //The node that contains it, will also be split by it.
 
 
   if(splitPosition > firstStart && splitPosition < firstEnd && splitPosition > secondStart && splitPosition < secondEnd) {
     //The split-position intersect with both first and second. Continue the intersection on both sides
 
     uint firstLeftNode = first->leftNode();
     uint firstRightNode = first->rightNode();
 
     uint secondLeftNode = second->leftNode();
     uint secondRightNode = second->rightNode();
 
     const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
     const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
     const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
     const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);
 
     Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
     Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());
 
     uint newLeftNode = set_intersect(firstLeftNode, secondLeftNode, firstLeft, secondLeft, splitBit);
     uint newRightNode = set_intersect(firstRightNode, secondRightNode, firstRight, secondRight, splitBit);
 
     if(newLeftNode && newRightNode)
       return createSetFromNodes( newLeftNode, newRightNode );
     else if(newLeftNode)
       return newLeftNode;
     else
       return newRightNode;
 
   }else if(splitPosition > firstStart && splitPosition < firstEnd) {
 
     uint firstLeftNode = first->leftNode();
     uint firstRightNode = first->rightNode();
 
     const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
     const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
 
     Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
 
     //splitPosition does not intersect second. That means that second is completely on one side of it.
     //So we can completely ignore the other side of first.
 
     if(secondEnd <= splitPosition) {
       return set_intersect(firstLeftNode, secondNode, firstLeft, second, splitBit);
     }else{
       Q_ASSERT(secondStart >= splitPosition);
       return set_intersect(firstRightNode, secondNode, firstRight, second, splitBit);
     }
   }else if(splitPosition > secondStart && splitPosition < secondEnd) {
 
     uint secondLeftNode = second->leftNode();
     uint secondRightNode = second->rightNode();
 
     const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
     const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);
 
     Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());
 
     if(firstEnd <= splitPosition) {
       return set_intersect(secondLeftNode, firstNode, secondLeft, first, splitBit);
     }else{
       Q_ASSERT(firstStart >= splitPosition);
       return set_intersect(secondRightNode, firstNode, secondRight, first, splitBit);
     }
   }else{
     //We would have stopped earlier of first and second don't intersect
     Q_ASSERT(0);
     return 0;
   }
   Q_ASSERT(0);
 }
 
 bool SetRepositoryAlgorithms::set_contains(const SetNodeData* node, Index index)
 {
   while(true) {
     if(node->start() > index || node->end() <= index)
       return false;
 
     if(node->contiguous())
       return true;
 
     const SetNodeData* leftNode = nodeFromIndex(node->leftNode());
 
     if(index < leftNode->end())
       node = leftNode;
     else {
       const SetNodeData* rightNode = nodeFromIndex(node->rightNode());
       node = rightNode;
     }
   }
 
   return false;
 }
 
 uint SetRepositoryAlgorithms::set_subtract(uint firstNode, uint secondNode, const SetNodeData* first, const SetNodeData* second, uchar splitBit)
 {
   if(firstNode == secondNode)
     return 0;
 
   if(first->start() >= second->end() || second->start() >= first->end())
     return firstNode;
 
   //The ranges of first and second do intersect
   uint firstStart = first->start(), firstEnd = first->end(), secondStart = second->start(), secondEnd = second->end();
 
   uint newStart = firstStart < secondStart ? firstStart : secondStart;
   uint newEnd = firstEnd > secondEnd ? firstEnd : secondEnd;
 
   //Compute the split-position for the resulting merged node
   uint splitPosition = splitPositionForRange(newStart, newEnd, splitBit);
 
   //Since the ranges overlap, we can be sure that either first or second contain splitPosition.
   //The node that contains it, will also be split by it.
 
   if(splitPosition > firstStart && splitPosition < firstEnd && splitPosition > secondStart && splitPosition < secondEnd) {
     //The split-position intersect with both first and second. Continue the subtract on both sides of the split-position, and merge it.
 
     uint firstLeftNode = first->leftNode();
     uint firstRightNode = first->rightNode();
 
     uint secondLeftNode = second->leftNode();
     uint secondRightNode = second->rightNode();
 
     const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
     const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
     const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
     const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);
 
 
     Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
     Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());
 
     uint newLeftNode = set_subtract(firstLeftNode, secondLeftNode, firstLeft, secondLeft, splitBit);
     uint newRightNode = set_subtract(firstRightNode, secondRightNode, firstRight, secondRight, splitBit);
 
     if(newLeftNode && newRightNode)
       return createSetFromNodes(newLeftNode, newRightNode);
     else if(newLeftNode)
       return newLeftNode;
     else
       return newRightNode;
 
   }else if(splitPosition > firstStart && splitPosition < firstEnd) {
 
 //    Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
 
     uint firstLeftNode = first->leftNode();
     uint firstRightNode = first->rightNode();
 
     const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
     const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
 
     //splitPosition does not intersect second. That means that second is completely on one side of it.
     //So we only need to subtract that side of first with second.
 
     uint newLeftNode = firstLeftNode, newRightNode = firstRightNode;
 
     if(secondEnd <= splitPosition) {
       newLeftNode = set_subtract(firstLeftNode, secondNode, firstLeft, second, splitBit);
     }else{
       Q_ASSERT(secondStart >= splitPosition);
       newRightNode = set_subtract(firstRightNode, secondNode, firstRight, second, splitBit);
     }
 
     if(newLeftNode && newRightNode)
       return createSetFromNodes(newLeftNode, newRightNode);
     else if(newLeftNode)
       return newLeftNode;
     else
       return newRightNode;
 
     }else if(splitPosition > secondStart && splitPosition < secondEnd) {
 
     uint secondLeftNode = second->leftNode();
     uint secondRightNode = second->rightNode();
 
     const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
     const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);
 
     Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());
 
     if(firstEnd <= splitPosition) {
       return set_subtract(firstNode, secondLeftNode, first, secondLeft, splitBit);
     }else{
       Q_ASSERT(firstStart >= splitPosition);
       return set_subtract(firstNode, secondRightNode, first, secondRight, splitBit);
     }
 
   }else{
     //We would have stopped earlier of first and second don't intersect
     Q_ASSERT(0);
     return 0;
   }
   Q_ASSERT(0);
 }
 
 Set BasicSetRepository::createSetFromIndices(const std::vector<Index>& indices) {
 
   QMutexLocker lock(m_mutex);
 
   if(indices.empty())
     return Set();
 
-  SetRepositoryAlgorithms alg(dataRepository, this);
+  SetRepositoryAlgorithms alg(m_dataRepository, this);
 
   return Set(alg.setForIndices(indices.begin(), indices.end()), this);
 }
 
 Set BasicSetRepository::createSet(Index i) {
     QMutexLocker lock(m_mutex);
     SetNodeData data(i, i+1);
 
-    return Set(dataRepository.index( SetNodeDataRequest(&data, dataRepository, this) ), this);
+    return Set(m_dataRepository.index( SetNodeDataRequest(&data, m_dataRepository, this) ), this);
 }
 
 Set BasicSetRepository::createSet(const std::set<Index>& indices) {
 
   if(indices.empty())
       return Set();
 
   QMutexLocker lock(m_mutex);
 
   std::vector<Index> indicesVector;
   indicesVector.reserve(indices.size());
 
   for( std::set<Index>::const_iterator it = indices.begin(); it != indices.end(); ++it )
     indicesVector.push_back(*it);
 
   return createSetFromIndices(indicesVector);
 }
 
 BasicSetRepository::BasicSetRepository(const QString& name, KDevelop::ItemRepositoryRegistry* registry, bool delayedDeletion)
-    : dataRepository(this, name, registry)
+    : m_dataRepository(this, name, registry)
     , m_mutex(nullptr)
     , m_delayedDeletion(delayedDeletion)
 {
-    m_mutex = dataRepository.mutex();
+    m_mutex = m_dataRepository.mutex();
 }
 
 struct StatisticsVisitor {
   explicit StatisticsVisitor(const SetDataRepository& _rep) : nodeCount(0), badSplitNodeCount(0), zeroRefCountNodes(0), rep(_rep) {
   }
   bool operator() (const SetNodeData* item) {
     if(item->m_refCount == 0)
         ++zeroRefCountNodes;
     ++nodeCount;
     uint split = splitPositionForRange(item->start(), item->end());
     if(item->hasSlaves())
       if(split < rep.itemFromIndex(item->leftNode())->end() || split > rep.itemFromIndex(item->rightNode())->start())
         ++badSplitNodeCount;
     return true;
   }
   uint nodeCount;
   uint badSplitNodeCount;
   uint zeroRefCountNodes;
   const SetDataRepository& rep;
 };
 
 void BasicSetRepository::printStatistics() const {
 
-  StatisticsVisitor stats(dataRepository);
-  dataRepository.visitAllItems<StatisticsVisitor>(stats);
+  StatisticsVisitor stats(m_dataRepository);
+  m_dataRepository.visitAllItems<StatisticsVisitor>(stats);
   qCDebug(LANGUAGE) << "count of nodes:" << stats.nodeCount << "count of nodes with bad split:" << stats.badSplitNodeCount << "count of nodes with zero reference-count:" << stats.zeroRefCountNodes;
 }
 
 BasicSetRepository::~BasicSetRepository() = default;
 
 void BasicSetRepository::itemRemovedFromSets(uint /*index*/) {
 }
 
 void BasicSetRepository::itemAddedToSets(uint /*index*/) {
 }
 
 ////////////Set convenience functions//////////////////
 
 bool Set::contains(Index index) const
 {
   if(!m_tree || !m_repository)
     return false;
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
-  return alg.set_contains(m_repository->dataRepository.itemFromIndex(m_tree), index);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
+  return alg.set_contains(m_repository->m_dataRepository.itemFromIndex(m_tree), index);
 }
 
 Set Set::operator +(const Set& first) const
 {
   if(!first.m_tree)
     return *this;
   else if(!m_tree || !m_repository)
     return first;
 
   Q_ASSERT(m_repository == first.m_repository);
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
 
-  uint retNode = alg.set_union(m_tree, first.m_tree, m_repository->dataRepository.itemFromIndex(m_tree), m_repository->dataRepository.itemFromIndex(first.m_tree));
+  uint retNode = alg.set_union(m_tree, first.m_tree, m_repository->m_dataRepository.itemFromIndex(m_tree), m_repository->m_dataRepository.itemFromIndex(first.m_tree));
 
   ifDebug(alg.check(retNode));
 
   return Set(retNode, m_repository);
 }
 
 Set& Set::operator +=(const Set& first) {
   if(!first.m_tree)
     return *this;
   else if(!m_tree || !m_repository) {
     m_tree = first.m_tree;
     m_repository = first.m_repository;
     return *this;
   }
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
 
-  m_tree = alg.set_union(m_tree, first.m_tree, m_repository->dataRepository.itemFromIndex(m_tree), m_repository->dataRepository.itemFromIndex(first.m_tree));
+  m_tree = alg.set_union(m_tree, first.m_tree, m_repository->m_dataRepository.itemFromIndex(m_tree), m_repository->m_dataRepository.itemFromIndex(first.m_tree));
 
   ifDebug(alg.check(m_tree));
   return *this;
 }
 
 Set Set::operator &(const Set& first) const {
   if(!first.m_tree || !m_tree)
     return Set();
 
   Q_ASSERT(m_repository);
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
 
-  Set ret( alg.set_intersect(m_tree, first.m_tree, m_repository->dataRepository.itemFromIndex(m_tree), m_repository->dataRepository.itemFromIndex(first.m_tree)), m_repository );
+  Set ret( alg.set_intersect(m_tree, first.m_tree, m_repository->m_dataRepository.itemFromIndex(m_tree), m_repository->m_dataRepository.itemFromIndex(first.m_tree)), m_repository );
 
   ifDebug(alg.check(ret.m_tree));
 
   return ret;
 }
 
 Set& Set::operator &=(const Set& first) {
   if(!first.m_tree || !m_tree) {
     m_tree = 0;
     return *this;
   }
 
   Q_ASSERT(m_repository);
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
 
-  m_tree = alg.set_intersect(m_tree, first.m_tree, m_repository->dataRepository.itemFromIndex(m_tree), m_repository->dataRepository.itemFromIndex(first.m_tree));
+  m_tree = alg.set_intersect(m_tree, first.m_tree, m_repository->m_dataRepository.itemFromIndex(m_tree), m_repository->m_dataRepository.itemFromIndex(first.m_tree));
   ifDebug(alg.check(m_tree));
   return *this;
 }
 
 Set Set::operator -(const Set& rhs) const {
   if(!m_tree || !rhs.m_tree)
     return *this;
 
   Q_ASSERT(m_repository);
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
 
-  Set ret( alg.set_subtract(m_tree, rhs.m_tree, m_repository->dataRepository.itemFromIndex(m_tree), m_repository->dataRepository.itemFromIndex(rhs.m_tree)), m_repository );
+  Set ret( alg.set_subtract(m_tree, rhs.m_tree, m_repository->m_dataRepository.itemFromIndex(m_tree), m_repository->m_dataRepository.itemFromIndex(rhs.m_tree)), m_repository );
   ifDebug( alg.check(ret.m_tree) );
   return ret;
 }
 
 Set& Set::operator -=(const Set& rhs) {
   if(!m_tree || !rhs.m_tree)
     return *this;
 
   Q_ASSERT(m_repository);
 
   QMutexLocker lock(m_repository->m_mutex);
 
-  SetRepositoryAlgorithms alg(m_repository->dataRepository, m_repository);
+  SetRepositoryAlgorithms alg(m_repository->m_dataRepository, m_repository);
 
-  m_tree = alg.set_subtract(m_tree, rhs.m_tree, m_repository->dataRepository.itemFromIndex(m_tree), m_repository->dataRepository.itemFromIndex(rhs.m_tree));
+  m_tree = alg.set_subtract(m_tree, rhs.m_tree, m_repository->m_dataRepository.itemFromIndex(m_tree), m_repository->m_dataRepository.itemFromIndex(rhs.m_tree));
 
   ifDebug(alg.check(m_tree));
   return *this;
 }
 
 BasicSetRepository* Set::repository() const {
   return m_repository;
 }
 
 void Set::staticRef() {
   if(!m_tree)
     return;
 
   QMutexLocker lock(m_repository->m_mutex);
-  SetNodeData* data = m_repository->dataRepository.dynamicItemFromIndexSimple(m_tree);
+  SetNodeData* data = m_repository->m_dataRepository.dynamicItemFromIndexSimple(m_tree);
   ++data->m_refCount;
 }
 
 ///Mutex must be locked
 void Set::unrefNode(uint current) {
-    SetNodeData* data = m_repository->dataRepository.dynamicItemFromIndexSimple(current);
+    SetNodeData* data = m_repository->m_dataRepository.dynamicItemFromIndexSimple(current);
     Q_ASSERT(data->m_refCount);
     --data->m_refCount;
     if(!m_repository->delayedDeletion()) {
         if(data->m_refCount == 0) {
 
             if(data->leftNode()){
                 Q_ASSERT(data->rightNode());
                 unrefNode(data->rightNode());
                 unrefNode(data->leftNode());
             }else {
                 //Deleting a leaf
                 Q_ASSERT(data->end() - data->start() == 1);
                 m_repository->itemRemovedFromSets(data->start());
             }
 
-        m_repository->dataRepository.deleteItem(current);
+        m_repository->m_dataRepository.deleteItem(current);
         }
     }
 }
 
 ///Decrease the static reference-count of this set by one. This set must have a reference-count > 1.
 ///If this set reaches the reference-count zero, it will be deleted, and all sub-nodes that also reach the reference-count zero
 ///will be deleted as well. @warning Either protect ALL your sets by using reference-counting, or don't use it at all.
 void Set::staticUnref() {
   if(!m_tree)
     return;
 
   QMutexLocker lock(m_repository->m_mutex);
 
   unrefNode(m_tree);
 }
 
 StringSetRepository::StringSetRepository(const QString& name) : Utils::BasicSetRepository(name) {
 }
 
 void StringSetRepository::itemRemovedFromSets(uint index) {
     ///Call the IndexedString destructor with enabled reference-counting
     KDevelop::IndexedString string = KDevelop::IndexedString::fromIndex(index);
 
     KDevelop::enableDUChainReferenceCounting(&string, sizeof(KDevelop::IndexedString));
     string.~IndexedString(); //Call destructor with enabled reference-counting
     KDevelop::disableDUChainReferenceCounting(&string);
 }
 
 void StringSetRepository::itemAddedToSets(uint index) {
     ///Call the IndexedString constructor with enabled reference-counting
 
     KDevelop::IndexedString string = KDevelop::IndexedString::fromIndex(index);
 
     char data[sizeof(KDevelop::IndexedString)];
 
     KDevelop::enableDUChainReferenceCounting(data, sizeof(KDevelop::IndexedString));
     new (data) KDevelop::IndexedString(string); //Call constructor with enabled reference-counting
     KDevelop::disableDUChainReferenceCounting(data);
 }
 
 }
 
diff --git a/kdevplatform/shell/filteredproblemstore.cpp b/kdevplatform/shell/filteredproblemstore.cpp
index 5081354e62..00c2e3bdbf 100644
--- a/kdevplatform/shell/filteredproblemstore.cpp
+++ b/kdevplatform/shell/filteredproblemstore.cpp
@@ -1,319 +1,319 @@
 /*
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "filteredproblemstore.h"
 
 #include "problem.h"
 #include "watcheddocumentset.h"
 #include "problemstorenode.h"
 
 #include <language/editor/documentrange.h>
 
 #include <KLocalizedString>
 
 using namespace KDevelop;
 
 namespace
 {
 
 /// Adds diagnostics as sub-nodes
 void addDiagnostics(ProblemStoreNode *node, const QVector<IProblem::Ptr> &diagnostics)
 {
     for (const IProblem::Ptr& ptr : diagnostics) {
         ProblemNode *child = new ProblemNode(node, ptr);
         node->addChild(child);
 
         addDiagnostics(child, ptr->diagnostics());
     }
 }
 
 /**
  * @brief Base class for grouping strategy classes
  *
  * These classes build the problem tree based on the respective strategies
  */
 class GroupingStrategy
 {
 public:
     explicit GroupingStrategy( ProblemStoreNode *root )
         : m_rootNode(root)
         , m_groupedRootNode(new ProblemStoreNode())
     {
     }
 
     virtual ~GroupingStrategy(){
     }
 
     /// Add a problem to the appropriate group
     virtual void addProblem(const IProblem::Ptr &problem) = 0;
 
     /// Find the specified noe
     const ProblemStoreNode* findNode(int row, ProblemStoreNode *parent = nullptr) const
     {
         if (parent == nullptr)
             return m_groupedRootNode->child(row);
         else
             return parent->child(row);
     }
 
     /// Returns the number of children nodes
     int count(ProblemStoreNode *parent = nullptr)
     {
         if (parent == nullptr)
             return m_groupedRootNode->count();
         else
             return parent->count();
     }
 
     /// Clears the problems
     virtual void clear()
     {
         m_groupedRootNode->clear();
     }
 
 protected:
     ProblemStoreNode* const m_rootNode;
     QScopedPointer<ProblemStoreNode> m_groupedRootNode;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// Implements no grouping strategy, that is just stores the problems without any grouping
 class NoGroupingStrategy final : public GroupingStrategy
 {
 public:
     explicit NoGroupingStrategy(ProblemStoreNode *root)
         : GroupingStrategy(root)
     {
     }
 
     void addProblem(const IProblem::Ptr &problem) override
     {
         ProblemNode *node = new ProblemNode(m_groupedRootNode.data(), problem);
         addDiagnostics(node, problem->diagnostics());
         m_groupedRootNode->addChild(node);
 
     }
 
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// Implements grouping based on path
 class PathGroupingStrategy final : public GroupingStrategy
 {
 public:
     explicit PathGroupingStrategy(ProblemStoreNode *root)
         : GroupingStrategy(root)
     {
     }
 
     void addProblem(const IProblem::Ptr &problem) override
     {
         QString path = problem->finalLocation().document.str();
 
         /// See if we already have this path
         ProblemStoreNode *parent = nullptr;
         foreach (ProblemStoreNode *node, m_groupedRootNode->children()) {
             if (node->label() == path) {
                 parent = node;
                 break;
             }
         }
 
         /// If not add it!
         if (parent == nullptr) {
             parent = new LabelNode(m_groupedRootNode.data(), path);
             m_groupedRootNode->addChild(parent);
         }
 
         ProblemNode *node = new ProblemNode(parent, problem);
         addDiagnostics(node, problem->diagnostics());
         parent->addChild(node);
     }
 
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// Implements grouping based on severity
 class SeverityGroupingStrategy final : public GroupingStrategy
 {
 public:
     enum SeverityGroups
     {
         GroupError          = 0,
         GroupWarning        = 1,
         GroupHint           = 2
     };
 
     explicit SeverityGroupingStrategy(ProblemStoreNode *root)
         : GroupingStrategy(root)
     {
         /// Create the groups on construction, so there's no need to search for them on addition
         m_groupedRootNode->addChild(new LabelNode(m_groupedRootNode.data(), i18n("Error")));
         m_groupedRootNode->addChild(new LabelNode(m_groupedRootNode.data(), i18n("Warning")));
         m_groupedRootNode->addChild(new LabelNode(m_groupedRootNode.data(), i18n("Hint")));
     }
 
     void addProblem(const IProblem::Ptr &problem) override
     {
         ProblemStoreNode *parent = nullptr;
 
         switch (problem->severity()) {
             case IProblem::Error: parent = m_groupedRootNode->child(GroupError); break;
             case IProblem::Warning: parent = m_groupedRootNode->child(GroupWarning); break;
             case IProblem::Hint: parent = m_groupedRootNode->child(GroupHint); break;
             default: break;
         }
 
         ProblemNode *node = new ProblemNode(m_groupedRootNode.data(), problem);
         addDiagnostics(node, problem->diagnostics());
         parent->addChild(node);
     }
 
     void clear() override
     {
         m_groupedRootNode->child(GroupError)->clear();
         m_groupedRootNode->child(GroupWarning)->clear();
         m_groupedRootNode->child(GroupHint)->clear();
     }
 };
 
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace KDevelop
 {
 
 class FilteredProblemStorePrivate
 {
 public:
     explicit FilteredProblemStorePrivate(FilteredProblemStore* q)
         : q(q)
         , m_strategy(new NoGroupingStrategy(q->rootNode()))
         , m_grouping(NoGrouping)
     {
     }
 
     /// Tells if the problem matches the filters
     bool match(const IProblem::Ptr &problem) const;
 
     FilteredProblemStore* const q;
     QScopedPointer<GroupingStrategy> m_strategy;
     GroupingMethod m_grouping;
 };
 
 FilteredProblemStore::FilteredProblemStore(QObject *parent)
     : ProblemStore(parent)
     , d(new FilteredProblemStorePrivate(this))
 {
 }
 
 FilteredProblemStore::~FilteredProblemStore()
 {
 }
 
 void FilteredProblemStore::addProblem(const IProblem::Ptr &problem)
 {
     ProblemStore::addProblem(problem);
 
     if (d->match(problem))
         d->m_strategy->addProblem(problem);
 }
 
 const ProblemStoreNode* FilteredProblemStore::findNode(int row, ProblemStoreNode *parent) const
 {
     return d->m_strategy->findNode(row, parent);
 }
 
 int FilteredProblemStore::count(ProblemStoreNode *parent) const
 {
     return d->m_strategy->count(parent);
 }
 
 void FilteredProblemStore::clear()
 {
     d->m_strategy->clear();
     ProblemStore::clear();
 }
 
 void FilteredProblemStore::rebuild()
 {
     emit beginRebuild();
 
     d->m_strategy->clear();
 
     foreach (ProblemStoreNode *node, rootNode()->children()) {
         IProblem::Ptr problem = node->problem();
         if (d->match(problem)) {
             d->m_strategy->addProblem(problem);
         }
     }
 
     emit endRebuild();
 }
 
 void FilteredProblemStore::setGrouping(int grouping)
 {
     GroupingMethod g = GroupingMethod(grouping);
     if(g == d->m_grouping)
         return;
 
     d->m_grouping = g;
 
     switch (g) {
         case NoGrouping: d->m_strategy.reset(new NoGroupingStrategy(rootNode())); break;
         case PathGrouping: d->m_strategy.reset(new PathGroupingStrategy(rootNode())); break;
         case SeverityGrouping: d->m_strategy.reset(new SeverityGroupingStrategy(rootNode())); break;
     }
 
     rebuild();
     emit changed();
 }
 
 int FilteredProblemStore::grouping() const
 {
     return d->m_grouping;
 }
 
 bool FilteredProblemStorePrivate::match(const IProblem::Ptr &problem) const
 {
     if (q->scope() != ProblemScope::BypassScopeFilter &&
         !q->documents()->get().contains(problem.data()->finalLocation().document) &&
-        !(q->showImports() && q->documents()->getImports().contains(problem.data()->finalLocation().document)))
+        !(q->showImports() && q->documents()->imports().contains(problem.data()->finalLocation().document)))
         return false;
 
     if(problem->severity()!=IProblem::NoSeverity)
     {
         /// If the problem severity isn't in the filter severities it's discarded
         if(!q->severities().testFlag(problem->severity()))
             return false;
     }
     else
     {
         if(!q->severities().testFlag(IProblem::Hint))//workaround for problems wothout correctly set severity
             return false;
     }
 
     return true;
 }
 
 }
diff --git a/kdevplatform/shell/problemstore.cpp b/kdevplatform/shell/problemstore.cpp
index 83eb7bd45c..2b1e02e7ce 100644
--- a/kdevplatform/shell/problemstore.cpp
+++ b/kdevplatform/shell/problemstore.cpp
@@ -1,278 +1,278 @@
 /*
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #include "problemstore.h"
 
 #include <language/editor/documentrange.h>
 #include <shell/problem.h>
 #include <shell/watcheddocumentset.h>
 #include "problemstorenode.h"
 
 namespace KDevelop
 {
 
 class ProblemStorePrivate
 {
 public:
     ProblemStorePrivate()
         : m_severities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning | KDevelop::IProblem::Hint)
         , m_rootNode(new KDevelop::ProblemStoreNode())
     {
     }
 
     /// Watched document set. Only problems that are in files in this set are stored.
     KDevelop::WatchedDocumentSet *m_documents = nullptr;
 
     /// The severity filter setting
     KDevelop::IProblem::Severities m_severities;
 
     /// The problems list
     KDevelop::ProblemStoreNode *m_rootNode;
 
     /// Path of the currently open document
     KDevelop::IndexedString m_currentDocument;
 
     /// All stored problems
     QVector<KDevelop::IProblem::Ptr> m_allProblems;
 };
 
 
 ProblemStore::ProblemStore(QObject *parent)
     : QObject(parent),
       d(new ProblemStorePrivate)
 {
     setScope(BypassScopeFilter);
 }
 
 ProblemStore::~ProblemStore()
 {
     clear();
 
     delete d->m_rootNode;
 }
 
 void ProblemStore::addProblem(const IProblem::Ptr &problem)
 {
     ProblemNode *node = new ProblemNode(d->m_rootNode);
     node->setProblem(problem);
     d->m_rootNode->addChild(node);
 
     d->m_allProblems += problem;
     emit problemsChanged();
 }
 
 void ProblemStore::setProblems(const QVector<IProblem::Ptr> &problems)
 {
     int oldSize = d->m_allProblems.size();
 
     // set signals block to prevent problemsChanged() emitting during clean
     {
         QSignalBlocker blocker(this);
         clear();
     }
 
     for (const IProblem::Ptr& problem : problems) {
         d->m_rootNode->addChild(new ProblemNode(d->m_rootNode, problem));
     }
 
     rebuild();
 
     if (d->m_allProblems.size() != oldSize || d->m_allProblems != problems) {
         d->m_allProblems = problems;
         emit problemsChanged();
     }
 }
 
 QVector<IProblem::Ptr> ProblemStore::problems(const KDevelop::IndexedString& document) const
 {
     QVector<IProblem::Ptr> documentProblems;
 
     foreach (auto problem, d->m_allProblems) {
         if (problem->finalLocation().document == document)
             documentProblems += problem;
     }
 
     return documentProblems;
 }
 
 const ProblemStoreNode* ProblemStore::findNode(int row, ProblemStoreNode *parent) const
 {
     Q_UNUSED(parent);
     return d->m_rootNode->child(row);
 }
 
 int ProblemStore::count(ProblemStoreNode *parent) const
 {
     if(parent)
         return parent->count();
     else
         return d->m_rootNode->count();
 }
 
 void ProblemStore::clear()
 {
     d->m_rootNode->clear();
 
     if (!d->m_allProblems.isEmpty()) {
         d->m_allProblems.clear();
         emit problemsChanged();
     }
 }
 
 void ProblemStore::rebuild()
 {
 }
 
 void ProblemStore::setSeverity(int severity)
 {
     switch (severity)
     {
         case KDevelop::IProblem::Error:
             setSeverities(KDevelop::IProblem::Error);
             break;
         case KDevelop::IProblem::Warning:
             setSeverities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning);
             break;
         case KDevelop::IProblem::Hint:
             setSeverities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning | KDevelop::IProblem::Hint);
             break;
     }
 }
 
 void ProblemStore::setSeverities(KDevelop::IProblem::Severities severities)
 {
     if(severities != d->m_severities)
     {
         d->m_severities = severities;
         rebuild();
         emit changed();
     }
 }
 
 int ProblemStore::severity() const
 {
     if (d->m_severities.testFlag(KDevelop::IProblem::Hint))
         return KDevelop::IProblem::Hint;
     if (d->m_severities.testFlag(KDevelop::IProblem::Warning))
         return KDevelop::IProblem::Warning;
     if (d->m_severities.testFlag(KDevelop::IProblem::Error))
         return KDevelop::IProblem::Error;
     return 0;
 }
 
 KDevelop::IProblem::Severities ProblemStore::severities() const
 {
     return d->m_severities;
 }
 
 WatchedDocumentSet* ProblemStore::documents() const
 {
     return d->m_documents;
 }
 
 void ProblemStore::setScope(int scope)
 {
     ProblemScope cast_scope = static_cast<ProblemScope>(scope);
     bool showImports = false;
 
     if (d->m_documents) {
-        if(cast_scope == d->m_documents->getScope())
+        if(cast_scope == d->m_documents->scope())
             return;
 
         showImports = d->m_documents->showImports();
         delete d->m_documents;
     }
 
     switch (cast_scope) {
     case CurrentDocument:
         d->m_documents = new CurrentDocumentSet(d->m_currentDocument, this);
         break;
     case OpenDocuments:
         d->m_documents = new OpenDocumentSet(this);
         break;
     case CurrentProject:
         d->m_documents = new CurrentProjectSet(d->m_currentDocument, this);
         break;
     case AllProjects:
         d->m_documents = new AllProjectSet(this);
         break;
     case BypassScopeFilter:
         d->m_documents = new BypassSet(this);
         break;
     }
 
     d->m_documents->setShowImports(showImports);
 
     rebuild();
 
     connect(d->m_documents, &WatchedDocumentSet::changed, this, &ProblemStore::onDocumentSetChanged);
 
     emit changed();
 }
 
 int ProblemStore::scope() const
 {
     Q_ASSERT(d->m_documents);
 
-    return d->m_documents->getScope();
+    return d->m_documents->scope();
 }
 
 void ProblemStore::setGrouping(int grouping)
 {
     Q_UNUSED(grouping);
 }
 
 void ProblemStore::setShowImports(bool showImports)
 {
     d->m_documents->setShowImports(showImports);
 }
 
 int ProblemStore::showImports() const
 {
     return d->m_documents->showImports();
 }
 
 void ProblemStore::setCurrentDocument(const IndexedString &doc)
 {
     d->m_currentDocument = doc;
     d->m_documents->setCurrentDocument(doc);
 }
 
 
 const KDevelop::IndexedString& ProblemStore::currentDocument() const
 {
     return d->m_currentDocument;
 }
 
 
 void ProblemStore::onDocumentSetChanged()
 {
     rebuild();
 
     emit changed();
 }
 
 ProblemStoreNode* ProblemStore::rootNode()
 {
     return d->m_rootNode;
 }
 
 }
 
diff --git a/kdevplatform/shell/uicontroller.cpp b/kdevplatform/shell/uicontroller.cpp
index ccaffeaf51..54bce103e2 100644
--- a/kdevplatform/shell/uicontroller.cpp
+++ b/kdevplatform/shell/uicontroller.cpp
@@ -1,757 +1,757 @@
 /***************************************************************************
  *   Copyright 2007 Alexander Dymo  <adymo@kdevelop.org>            *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 #include "uicontroller.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QDialog>
 #include <QListWidget>
 #include <QPushButton>
 #include <QMap>
 #include <QPointer>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KXMLGUIClient>
 
 #include <sublime/area.h>
 #include <sublime/view.h>
 #include <sublime/tooldocument.h>
 #include <sublime/holdupdates.h>
 
 #include <interfaces/itoolviewactionlistener.h>
 #include <util/scopeddialog.h>
 
 #include "core.h"
 #include "configpage.h"
 #include "configdialog.h"
 #include "debug.h"
 #include "editorconfigpage.h"
 #include "shellextension.h"
 #include "plugincontroller.h"
 #include "mainwindow.h"
 #include "workingsetcontroller.h"
 #include "workingsets/workingset.h"
 #include "settings/bgpreferences.h"
 #include "settings/languagepreferences.h"
 #include "settings/environmentpreferences.h"
 #include "settings/pluginpreferences.h"
 #include "settings/projectpreferences.h"
 #include "settings/sourceformattersettings.h"
 #include "settings/uipreferences.h"
 #include "settings/templateconfig.h"
 #include "settings/analyzerspreferences.h"
 #include "settings/documentationpreferences.h"
 #include "settings/runtimespreferences.h"
 
 namespace KDevelop {
 
 class UiControllerPrivate {
 public:
     UiControllerPrivate(Core* core, UiController* controller)
         : core(core)
         , areasRestored(false)
         , m_controller(controller)
     {
         if (Core::self()->workingSetControllerInternal())
             Core::self()->workingSetControllerInternal()->initializeController(m_controller);
 
         m_controller->connect(m_controller, &Sublime::Controller::mainWindowAdded, m_controller, &UiController::mainWindowAdded);
 
         QMap<QString, Sublime::Position> desired;
 
         desired[QStringLiteral("org.kdevelop.ClassBrowserView")] = Sublime::Left;
         desired[QStringLiteral("org.kdevelop.DocumentsView")] = Sublime::Left;
         desired[QStringLiteral("org.kdevelop.ProjectsView")] = Sublime::Left;
         desired[QStringLiteral("org.kdevelop.FileManagerView")] = Sublime::Left;
         desired[QStringLiteral("org.kdevelop.ProblemReporterView")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.OutputView")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.ContextBrowser")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.KonsoleView")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.SnippetView")] = Sublime::Right;
         desired[QStringLiteral("org.kdevelop.ExternalScriptView")] = Sublime::Right;
         Sublime::Area* a =
             new Sublime::Area(m_controller, QStringLiteral("code"), i18n("Code"));
         a->setDesiredToolViews(desired);
         a->setIconName(QStringLiteral("document-edit"));
         m_controller->addDefaultArea(a);
 
         desired.clear();
         desired[QStringLiteral("org.kdevelop.debugger.VariablesView")] = Sublime::Left;
         desired[QStringLiteral("org.kdevelop.debugger.BreakpointsView")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.debugger.StackView")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.debugger.ConsoleView")] = Sublime::Bottom;
         desired[QStringLiteral("org.kdevelop.KonsoleView")] = Sublime::Bottom;
         a = new Sublime::Area(m_controller, QStringLiteral("debug"), i18n("Debug"));
         a->setDesiredToolViews(desired);
         a->setIconName(QStringLiteral("debug-run"));
         m_controller->addDefaultArea(a);
 
         desired.clear();
         desired[QStringLiteral("org.kdevelop.ProjectsView")] = Sublime::Left;
         desired[QStringLiteral("org.kdevelop.PatchReview")] = Sublime::Bottom;
 
         a = new Sublime::Area(m_controller, QStringLiteral("review"), i18n("Review"));
         a->setDesiredToolViews(desired);
         a->setIconName(QStringLiteral("text-x-patch"));
         m_controller->addDefaultArea(a);
 
         if(!(Core::self()->setupFlags() & Core::NoUi))
         {
             defaultMainWindow = new MainWindow(m_controller);
             m_controller->addMainWindow(defaultMainWindow);
             activeSublimeWindow = defaultMainWindow;
         }
         else
         {
             activeSublimeWindow = defaultMainWindow = nullptr;
         }
 
         m_assistantTimer.setSingleShot(true);
         m_assistantTimer.setInterval(100);
     }
 
     void widgetChanged(QWidget*, QWidget* now)
     {
         if (now) {
             Sublime::MainWindow* win = qobject_cast<Sublime::MainWindow*>(now->window());
             if( win )
             {
                 activeSublimeWindow = win;
             }
         }
     }
 
     Core* const core;
     QPointer<MainWindow> defaultMainWindow;
 
     QHash<IToolViewFactory*, Sublime::ToolDocument*> factoryDocuments;
 
     QPointer<Sublime::MainWindow> activeSublimeWindow;
     bool areasRestored;
 
     /// QWidget implementing IToolViewActionListener interface, or null
     QPointer<QWidget> activeActionListener;
     QTimer m_assistantTimer;
 
 private:
     UiController *m_controller;
 };
 
 
 class UiToolViewFactory: public Sublime::ToolFactory {
 public:
     explicit UiToolViewFactory(IToolViewFactory *factory): m_factory(factory) {}
     ~UiToolViewFactory() override { delete m_factory; }
     QWidget* create(Sublime::ToolDocument *doc, QWidget *parent = nullptr) override
     {
         Q_UNUSED( doc );
         return m_factory->create(parent);
     }
 
     QList< QAction* > contextMenuActions(QWidget* viewWidget) const override
     {
         return m_factory->contextMenuActions( viewWidget );
     }
 
     QList<QAction*> toolBarActions( QWidget* viewWidget ) const override
     {
         return m_factory->toolBarActions( viewWidget );
     }
 
     QString id() const override { return m_factory->id(); }
 private:
     IToolViewFactory* const m_factory;
 };
 
 
 class ViewSelectorItem: public QListWidgetItem {
 public:
     explicit ViewSelectorItem(const QString& text, IToolViewFactory* factory, QListWidget* parent = nullptr, int type = Type)
         : QListWidgetItem(text, parent, type)
         , factory(factory)
     {}
     IToolViewFactory* const factory;
 };
 
 
 class NewToolViewListWidget: public QListWidget {
     Q_OBJECT
 
 public:
     explicit NewToolViewListWidget(MainWindow *mw, QWidget* parent = nullptr)
         :QListWidget(parent), m_mw(mw)
     {
         connect(this, &NewToolViewListWidget::doubleClicked, this, &NewToolViewListWidget::addNewToolViewByDoubleClick);
     }
 
 Q_SIGNALS:
     void addNewToolView(MainWindow *mw, QListWidgetItem *item);
 
 private Q_SLOTS:
     void addNewToolViewByDoubleClick(const QModelIndex& index)
     {
         QListWidgetItem *item = itemFromIndex(index);
         // Disable item so that the tool view can not be added again.
         item->setFlags(item->flags() & ~Qt::ItemIsEnabled);
         emit addNewToolView(m_mw, item);
     }
 
 private:
     MainWindow* const m_mw;
 };
 
 UiController::UiController(Core *core)
     :Sublime::Controller(nullptr), IUiController(), d(new UiControllerPrivate(core, this))
 {
     setObjectName(QStringLiteral("UiController"));
 
     if (!defaultMainWindow() || (Core::self()->setupFlags() & Core::NoUi))
         return;
 
     connect(qApp, &QApplication::focusChanged,
             this, [&] (QWidget* old, QWidget* now) { d->widgetChanged(old, now); } );
 
     setupActions();
 }
 
 UiController::~UiController() = default;
 
 void UiController::setupActions()
 {
 }
 
 void UiController::mainWindowAdded(Sublime::MainWindow* mainWindow)
 {
     connect(mainWindow, &MainWindow::activeToolViewChanged, this, &UiController::slotActiveToolViewChanged);
     connect(mainWindow, &MainWindow::areaChanged, this, &UiController::slotAreaChanged); // also check after area reconstruction
 }
 
 // FIXME: currently, this always create new window. Probably,
 // should just rename it.
 void UiController::switchToArea(const QString &areaName, SwitchMode switchMode)
 {
     if (switchMode == ThisWindow) {
         showArea(areaName, activeSublimeWindow());
         return;
     }
 
     MainWindow *main = new MainWindow(this);
 
     addMainWindow(main);
     showArea(areaName, main);
     main->initialize();
 
     // WTF? First, enabling this code causes crashes since we
     // try to disconnect some already-deleted action, or something.
     // Second, this code will disconnection the clients from guiFactory
     // of the previous main window. Ick!
 #if 0
     //we need to add all existing guiclients to the new mainwindow
     //@todo adymo: add only ones that belong to the area (when the area code is there)
     foreach (KXMLGUIClient *client, oldMain->guiFactory()->clients())
         main->guiFactory()->addClient(client);
 #endif
 
     main->show();
 }
 
 
 QWidget* UiController::findToolView(const QString& name, IToolViewFactory *factory, FindFlags flags)
 {
     if(!d->areasRestored || !activeArea())
         return nullptr;
 
     const QList<Sublime::View*> views = activeArea()->toolViews();
     for (Sublime::View* view : views) {
         Sublime::ToolDocument *doc = dynamic_cast<Sublime::ToolDocument*>(view->document());
         if(doc && doc->title() == name && view->widget()) {
             if(flags & Raise)
                 view->requestRaise();
             return view->widget();
         }
     }
 
     QWidget* ret = nullptr;
 
     if(flags & Create)
     {
         Sublime::ToolDocument* doc = d->factoryDocuments.value(factory);
         if(!doc) {
             doc = new Sublime::ToolDocument(name, this, new UiToolViewFactory(factory));
             d->factoryDocuments.insert(factory, doc);
         }
 
         Sublime::View* view = addToolViewToArea(factory, doc, activeArea());
         if(view)
             ret = view->widget();
 
         if(flags & Raise)
             findToolView(name, factory, Raise);
     }
 
     return ret;
 }
 
 void UiController::raiseToolView(QWidget* toolViewWidget)
 {
     if(!d->areasRestored)
         return;
 
     const QList<Sublime::View*> views = activeArea()->toolViews();
     for (Sublime::View* view : views) {
         if(view->widget() == toolViewWidget) {
             view->requestRaise();
             return;
         }
     }
 }
 
 void UiController::addToolView(const QString & name, IToolViewFactory *factory, FindFlags state)
 {
     if (!factory)
         return;
 
     qCDebug(SHELL) ;
     Sublime::ToolDocument *doc = new Sublime::ToolDocument(name, this, new UiToolViewFactory(factory));
     d->factoryDocuments[factory] = doc;
 
     /* Until areas are restored, we don't know which views should be really
        added, and which not, so we just record view availability.  */
     if (d->areasRestored && state != None) {
          foreach (Sublime::Area* area, allAreas()) {
              addToolViewToArea(factory, doc, area);
          }
     }
 }
 
 void KDevelop::UiController::raiseToolView(Sublime::View * view)
 {
     foreach( Sublime::Area* area, allAreas() ) {
         if( area->toolViews().contains( view ) )
             area->raiseToolView( view );
     }
 
     slotActiveToolViewChanged(view);
 }
 
 void UiController::slotAreaChanged(Sublime::Area*)
 {
     // this slot gets call if an area in *any* MainWindow changed
     // so let's first get the "active area"
     const auto area = activeSublimeWindow()->area();
     if (area) {
         // walk through shown tool views and maku sure the
         const auto shownIds = area->shownToolViews(Sublime::AllPositions);
         foreach (Sublime::View* toolView, area->toolViews()) {
             if (shownIds.contains(toolView->document()->documentSpecifier())) {
                 slotActiveToolViewChanged(toolView);
             }
         }
     }
 }
 
 void UiController::slotActiveToolViewChanged(Sublime::View* view)
 {
     if (!view) {
         return;
     }
 
     // record the last active tool view action listener
     if (qobject_cast<IToolViewActionListener*>(view->widget())) {
         d->activeActionListener = view->widget();
     }
 }
 
 void KDevelop::UiController::removeToolView(IToolViewFactory *factory)
 {
     if (!factory)
         return;
 
     qCDebug(SHELL) ;
     //delete the tooldocument
     Sublime::ToolDocument *doc = d->factoryDocuments.value(factory);
 
     ///@todo adymo: on document deletion all its views shall be also deleted
     foreach (Sublime::View *view, doc->views()) {
         foreach (Sublime::Area *area, allAreas())
             if (area->removeToolView(view))
                 view->deleteLater();
     }
 
     d->factoryDocuments.remove(factory);
     delete doc;
 }
 
 Sublime::Area *UiController::activeArea()
 {
     Sublime::MainWindow *m = activeSublimeWindow();
     if (m)
         return activeSublimeWindow()->area();
     return nullptr;
 }
 
 Sublime::MainWindow *UiController::activeSublimeWindow()
 {
     return d->activeSublimeWindow;
 }
 
 MainWindow *UiController::defaultMainWindow()
 {
     return d->defaultMainWindow;
 }
 
 void UiController::initialize()
 {
     defaultMainWindow()->initialize();
 }
 
 
 void UiController::cleanup()
 {
     foreach (Sublime::MainWindow* w, mainWindows())
         w->saveSettings();
     saveAllAreas(KSharedConfig::openConfig());
 }
 
 void UiController::selectNewToolViewToAdd(MainWindow *mw)
 {
     if (!mw || !mw->area())
         return;
 
     ScopedDialog<QDialog> dia(mw);
     dia->setWindowTitle(i18n("Select Tool View to Add"));
 
     auto mainLayout = new QVBoxLayout(dia);
 
     NewToolViewListWidget *list = new NewToolViewListWidget(mw, dia);
 
     list->setSelectionMode(QAbstractItemView::ExtendedSelection);
     list->setSortingEnabled(true);
     for (QHash<IToolViewFactory*, Sublime::ToolDocument*>::const_iterator it = d->factoryDocuments.constBegin();
         it != d->factoryDocuments.constEnd(); ++it)
     {
         ViewSelectorItem *item = new ViewSelectorItem(it.value()->title(), it.key(), list);
         if (!item->factory->allowMultiple() && toolViewPresent(it.value(), mw->area())) {
             // Disable item if the tool view is already present.
             item->setFlags(item->flags() & ~Qt::ItemIsEnabled);
         }
         list->addItem(item);
     }
 
     list->setFocus();
     connect(list, &NewToolViewListWidget::addNewToolView, this, &UiController::addNewToolView);
     mainLayout->addWidget(list);
 
     auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     auto okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     dia->connect(buttonBox, &QDialogButtonBox::accepted, dia.data(), &QDialog::accept);
     dia->connect(buttonBox, &QDialogButtonBox::rejected, dia.data(), &QDialog::reject);
     mainLayout->addWidget(buttonBox);
 
     if (dia->exec() == QDialog::Accepted)
     {
         foreach (QListWidgetItem* item, list->selectedItems())
         {
             addNewToolView(mw, item);
         }
     }
 }
 
 void UiController::addNewToolView(MainWindow *mw, QListWidgetItem* item)
 {
     ViewSelectorItem *current = static_cast<ViewSelectorItem*>(item);
     Sublime::ToolDocument *doc = d->factoryDocuments[current->factory];
     Sublime::View *view = doc->createView();
     mw->area()->addToolView(view,
         Sublime::dockAreaToPosition(current->factory->defaultPosition()));
     current->factory->viewCreated(view);
 }
 
 void UiController::showSettingsDialog()
 {
     ConfigDialog cfgDlg(activeMainWindow());
 
     auto editorConfigPage = new EditorConfigPage(&cfgDlg);
     auto languageConfigPage = new LanguagePreferences(&cfgDlg);
     auto analyzersPreferences = new AnalyzersPreferences(&cfgDlg);
     auto documentationPreferences = new DocumentationPreferences(&cfgDlg);
     auto runtimesPreferences = new RuntimesPreferences(&cfgDlg);
     auto templateConfig = new TemplateConfig(&cfgDlg);
 
     const auto configPages = QVector<KDevelop::ConfigPage*> {
         new UiPreferences(&cfgDlg),
         new PluginPreferences(&cfgDlg),
         new SourceFormatterSettings(&cfgDlg),
         new ProjectPreferences(&cfgDlg),
         new EnvironmentPreferences(QString(), &cfgDlg),
         templateConfig,
         editorConfigPage
     };
 
     for (auto page : configPages) {
         cfgDlg.appendConfigPage(page);
     }
 
     auto addPluginPages = [&](IPlugin* plugin) {
         for (int i = 0, numPages = plugin->configPages(); i < numPages; ++i) {
             auto page = plugin->configPage(i, &cfgDlg);
             if (!page)
                 continue;
 
             if (page->configPageType() == ConfigPage::LanguageConfigPage) {
                 cfgDlg.appendSubConfigPage(languageConfigPage, page);
             } else if (page->configPageType() == ConfigPage::AnalyzerConfigPage) {
                 cfgDlg.appendSubConfigPage(analyzersPreferences, page);
             } else if (page->configPageType() == ConfigPage::RuntimeConfigPage) {
                 cfgDlg.appendSubConfigPage(runtimesPreferences, page);
             } else if (page->configPageType() == ConfigPage::DocumentationConfigPage) {
                 cfgDlg.appendSubConfigPage(documentationPreferences, page);
             } else {
                 cfgDlg.insertConfigPage(editorConfigPage, page);
             }
         }
     };
 
     cfgDlg.insertConfigPage(templateConfig, documentationPreferences);
     cfgDlg.insertConfigPage(documentationPreferences, analyzersPreferences);
     cfgDlg.insertConfigPage(analyzersPreferences, runtimesPreferences);
 
     cfgDlg.insertConfigPage(runtimesPreferences, languageConfigPage);
     cfgDlg.appendSubConfigPage(languageConfigPage, new BGPreferences(&cfgDlg));
 
     foreach (IPlugin* plugin, ICore::self()->pluginController()->loadedPlugins()) {
         addPluginPages(plugin);
     }
 
     // TODO: only load settings if a UI related page was changed?
     connect(&cfgDlg, &ConfigDialog::configSaved, activeSublimeWindow(), &Sublime::MainWindow::loadSettings);
     // make sure that pages get added whenever a new plugin is loaded (probably from the plugin selection dialog)
     // removal on plugin unload is already handled in ConfigDialog
     connect(ICore::self()->pluginController(), &IPluginController::pluginLoaded, &cfgDlg, addPluginPages);
     cfgDlg.exec();
 }
 
 Sublime::Controller* UiController::controller()
 {
     return this;
 }
 
 KParts::MainWindow *UiController::activeMainWindow()
 {
     return activeSublimeWindow();
 }
 
 void UiController::saveArea(Sublime::Area * area, KConfigGroup & group)
 {
     area->save(group);
     if (!area->workingSet().isEmpty()) {
-        WorkingSet* set = Core::self()->workingSetControllerInternal()->getWorkingSet(area->workingSet());
+        WorkingSet* set = Core::self()->workingSetControllerInternal()->workingSet(area->workingSet());
         set->saveFromArea(area, area->rootIndex());
     }
 }
 
 void UiController::loadArea(Sublime::Area * area, const KConfigGroup & group)
 {
     area->load(group);
     if (!area->workingSet().isEmpty()) {
-        WorkingSet* set = Core::self()->workingSetControllerInternal()->getWorkingSet(area->workingSet());
+        WorkingSet* set = Core::self()->workingSetControllerInternal()->workingSet(area->workingSet());
         Q_ASSERT(set->isConnected(area));
         Q_UNUSED(set);
     }
 }
 
 void UiController::saveAllAreas(const KSharedConfigPtr& config)
 {
     KConfigGroup uiConfig(config, "User Interface");
     int wc = mainWindows().size();
     uiConfig.writeEntry("Main Windows Count", wc);
     for (int w = 0; w < wc; ++w)
     {
         KConfigGroup mainWindowConfig(&uiConfig,
                                       QStringLiteral("Main Window %1").arg(w));
 
         foreach (Sublime::Area* defaultArea, defaultAreas())
         {
             // FIXME: using object name seems ugly.
             QString type = defaultArea->objectName();
             Sublime::Area* area = this->area(w, type);
             KConfigGroup areaConfig(&mainWindowConfig, QLatin1String("Area ") + type);
 
             areaConfig.deleteGroup();
             areaConfig.writeEntry("id", type);
             saveArea(area, areaConfig);
             areaConfig.sync();
         }
     }
     uiConfig.sync();
 }
 
 void UiController::loadAllAreas(const KSharedConfigPtr& config)
 {
     KConfigGroup uiConfig(config, "User Interface");
     int wc = uiConfig.readEntry("Main Windows Count", 1);
 
     /* It is expected the main windows are restored before
        restoring areas.  */
     if (wc > mainWindows().size())
         wc = mainWindows().size();
 
     /* Offer all tool views to the default areas.  */
     foreach (Sublime::Area *area, defaultAreas())
     {
         QHash<IToolViewFactory*, Sublime::ToolDocument*>::const_iterator i, e;
         for (i = d->factoryDocuments.constBegin(),
                  e = d->factoryDocuments.constEnd(); i != e; ++i)
         {
             addToolViewIfWanted(i.key(), i.value(), area);
         }
     }
 
     /* Restore per-windows areas.  */
     for (int w = 0; w < wc; ++w)
     {
         KConfigGroup mainWindowConfig(&uiConfig,
                                       QStringLiteral("Main Window %1").arg(w));
 
         Sublime::MainWindow *mw = mainWindows()[w];
 
         /* We loop over default areas.  This means that if
            the config file has an area of some type that is not
            in default set, we'd just ignore it.  I think it's fine --
            the model were a given mainwindow can has it's own
            area types not represented in the default set is way
            too complex.  */
         foreach (Sublime::Area* defaultArea, defaultAreas())
         {
             QString type = defaultArea->objectName();
             Sublime::Area* area = this->area(w, type);
 
             KConfigGroup areaConfig(&mainWindowConfig, QLatin1String("Area ") + type);
 
             qCDebug(SHELL) << "Trying to restore area " << type;
 
             /* This is just an easy check that a group exists, to
                avoid "restoring" area from empty config group, wiping
                away programmatically installed defaults.  */
             if (areaConfig.readEntry("id", "") == type)
             {
                 qCDebug(SHELL) << "Restoring area " << type;
                 loadArea(area, areaConfig);
             }
 
             // At this point we know which tool views the area wants.
             // Tender all tool views we have.
             QHash<IToolViewFactory*, Sublime::ToolDocument*>::const_iterator i, e;
             for (i = d->factoryDocuments.constBegin(),
                      e = d->factoryDocuments.constEnd(); i != e; ++i)
             {
                 addToolViewIfWanted(i.key(), i.value(), area);
             }
         }
 
         // Force reload of the changes.
         showAreaInternal(mw->area(), mw);
 
         mw->enableAreaSettingsSave();
     }
 
     d->areasRestored = true;
 }
 
 void UiController::addToolViewToDockArea(IToolViewFactory* factory, Qt::DockWidgetArea area)
 {
     addToolViewToArea(factory, d->factoryDocuments.value(factory), activeArea(), Sublime::dockAreaToPosition(area));
 }
 
 bool UiController::toolViewPresent(Sublime::ToolDocument* doc, Sublime::Area* area)
 {
     for (Sublime::View *view : doc->views()) {
         if( area->toolViews().contains( view ) )
             return true;
     }
     return false;
 }
 
 void UiController::addToolViewIfWanted(IToolViewFactory* factory,
                            Sublime::ToolDocument* doc,
                            Sublime::Area* area)
 {
     if (area->wantToolView(factory->id()))
     {
         addToolViewToArea(factory, doc, area);
     }
 }
 
 Sublime::View* UiController::addToolViewToArea(IToolViewFactory* factory,
                                      Sublime::ToolDocument* doc,
                                      Sublime::Area* area, Sublime::Position p)
 {
     Sublime::View* view = doc->createView();
     area->addToolView(
         view,
         p == Sublime::AllPositions ? Sublime::dockAreaToPosition(factory->defaultPosition()) : p);
 
     connect(view, &Sublime::View::raise,
             this, static_cast<void(UiController::*)(Sublime::View*)>(&UiController::raiseToolView));
 
     factory->viewCreated(view);
     return view;
 }
 
 void UiController::registerStatus(QObject* status)
 {
     Sublime::MainWindow* w = activeSublimeWindow();
     if (!w) return;
     MainWindow* mw = qobject_cast<KDevelop::MainWindow*>(w);
     if (!mw) return;
     mw->registerStatus(status);
 }
 
 void UiController::showErrorMessage(const QString& message, int timeout)
 {
     Sublime::MainWindow* w = activeSublimeWindow();
     if (!w) return;
     MainWindow* mw = qobject_cast<KDevelop::MainWindow*>(w);
     if (!mw) return;
     QMetaObject::invokeMethod(mw, "showErrorMessage", Q_ARG(QString, message), Q_ARG(int, timeout));
 }
 
 const QHash< IToolViewFactory*, Sublime::ToolDocument* >& UiController::factoryDocuments() const
 {
     return d->factoryDocuments;
 }
 
 QWidget* UiController::activeToolViewActionListener() const
 {
     return d->activeActionListener;
 }
 
 QList<Sublime::Area*> UiController::allAreas() const
 {
     return Sublime::Controller::allAreas();
 }
 
 }
 
 #include "uicontroller.moc"
 #include "moc_uicontroller.cpp"
diff --git a/kdevplatform/shell/watcheddocumentset.cpp b/kdevplatform/shell/watcheddocumentset.cpp
index b5f3a42ae6..0e71c74f3e 100644
--- a/kdevplatform/shell/watcheddocumentset.cpp
+++ b/kdevplatform/shell/watcheddocumentset.cpp
@@ -1,361 +1,361 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2010 Dmitry Risenberg <dmitry.risenberg@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 #include "watcheddocumentset.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/idocument.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/topducontext.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/projectmodel.h>
 
 namespace KDevelop
 {
 
 enum ActionFlag {
     DoUpdate = 1,
     DoEmit = 2
 };
 Q_DECLARE_FLAGS(ActionFlags, ActionFlag)
 Q_DECLARE_OPERATORS_FOR_FLAGS(ActionFlags)
 
 class WatchedDocumentSetPrivate : public QObject
 {
     Q_OBJECT
 
 public:
     using DocumentSet = WatchedDocumentSet::DocumentSet;
 
     explicit WatchedDocumentSetPrivate(WatchedDocumentSet* documentSet)
         : m_documentSet(documentSet)
         , m_showImports(false)
     {
         connect(DUChain::self(), &DUChain::updateReady, this, &WatchedDocumentSetPrivate::updateReady);
     }
 
     inline bool showImports() const
     {
         return m_showImports;
     }
 
     void setShowImports(bool showImports)
     {
         if (m_showImports == showImports)
             return;
 
         DocumentSet oldImports = m_imports;
 
         m_showImports = showImports;
         updateImports();
 
         if (m_imports != oldImports)
             emit m_documentSet->changed();
     }
 
     inline const DocumentSet& documents() const
     {
         return m_documents;
     }
 
     inline const DocumentSet& imports() const
     {
         return m_imports;
     }
 
     inline void doUpdate(ActionFlags flags)
     {
         if (flags.testFlag(DoUpdate))
             updateImports();
 
         if (flags.testFlag(DoEmit))
             emit m_documentSet->changed();
     }
 
     void setDocuments(const DocumentSet& docs, ActionFlags flags = {})
     {
         m_documents = docs;
         doUpdate(flags);
     }
 
     void addDocument(const IndexedString& doc, ActionFlags flags = {})
     {
         if (m_documents.contains(doc))
             return;
 
         m_documents.insert(doc);
         doUpdate(flags);
     }
 
     void delDocument(const IndexedString& doc, ActionFlags flags = {})
     {
         if (!m_documents.contains(doc))
             return;
 
         m_documents.remove(doc);
         doUpdate(flags);
     }
 
     void updateImports()
     {
         if (!m_showImports) {
             if (!m_imports.isEmpty()) {
                 m_imports.clear();
                 return;
             }
             return;
         }
 
         getImportsFromDUChain();
     }
 
 private:
     void getImportsFromDU(TopDUContext* context, QSet<TopDUContext*>& visitedContexts)
     {
         if (!context || visitedContexts.contains(context))
             return;
 
         visitedContexts.insert(context);
         foreach (const DUContext::Import& ctx, context->importedParentContexts()) {
             TopDUContext* topCtx = dynamic_cast<TopDUContext*>(ctx.context(nullptr));
 
             if (topCtx)
                 getImportsFromDU(topCtx, visitedContexts);
         }
     }
 
     void getImportsFromDUChain()
     {
         KDevelop::DUChainReadLocker lock;
         QSet<TopDUContext*> visitedContexts;
 
         m_imports.clear();
         foreach (const IndexedString& doc, m_documents) {
             TopDUContext* ctx = DUChain::self()->chainForDocument(doc);
             getImportsFromDU(ctx, visitedContexts);
             visitedContexts.remove(ctx);
         }
 
         foreach (TopDUContext* ctx, visitedContexts) {
             m_imports.insert(ctx->url());
         }
     }
 
     void updateReady(const IndexedString& doc, const ReferencedTopDUContext&)
     {
         if (!m_showImports || !m_documents.contains(doc))
             return;
 
         DocumentSet oldImports = m_imports;
 
         updateImports();
         if (m_imports != oldImports)
             emit m_documentSet->changed();
     }
 
     WatchedDocumentSet* m_documentSet;
 
     DocumentSet m_documents;
     DocumentSet m_imports;
 
     bool m_showImports;
 };
 
 WatchedDocumentSet::WatchedDocumentSet(QObject* parent)
     : QObject(parent)
     , d(new WatchedDocumentSetPrivate(this))
 {
 }
 
 WatchedDocumentSet::~WatchedDocumentSet()
 {
 }
 
 bool WatchedDocumentSet::showImports() const
 {
     return d->showImports();
 }
 
 void WatchedDocumentSet::setShowImports(bool showImports)
 {
     d->setShowImports(showImports);
 }
 
 void WatchedDocumentSet::setCurrentDocument(const IndexedString&)
 {
 }
 
 WatchedDocumentSet::DocumentSet WatchedDocumentSet::get() const
 {
     return d->documents();
 }
 
-WatchedDocumentSet::DocumentSet WatchedDocumentSet::getImports() const
+WatchedDocumentSet::DocumentSet WatchedDocumentSet::imports() const
 {
     return d->imports();
 }
 
 CurrentDocumentSet::CurrentDocumentSet(const IndexedString& document, QObject* parent)
     : WatchedDocumentSet(parent)
 {
     d->setDocuments({document}, DoUpdate);
 }
 
 void CurrentDocumentSet::setCurrentDocument(const IndexedString& url)
 {
     d->setDocuments({url}, DoUpdate | DoEmit);
 }
 
-ProblemScope CurrentDocumentSet::getScope() const
+ProblemScope CurrentDocumentSet::scope() const
 {
     return CurrentDocument;
 }
 
 OpenDocumentSet::OpenDocumentSet(QObject* parent)
     : WatchedDocumentSet(parent)
 {
     foreach (IDocument* doc, ICore::self()->documentController()->openDocuments()) {
         d->addDocument(IndexedString(doc->url()));
     }
     d->updateImports();
 
     connect(ICore::self()->documentController(), &IDocumentController::documentClosed, this, &OpenDocumentSet::documentClosed);
     connect(ICore::self()->documentController(), &IDocumentController::textDocumentCreated, this, &OpenDocumentSet::documentCreated);
 }
 
 void OpenDocumentSet::documentClosed(IDocument* doc)
 {
     d->delDocument(IndexedString(doc->url()), DoUpdate | DoEmit);
 }
 
 void OpenDocumentSet::documentCreated(IDocument* doc)
 {
     d->addDocument(IndexedString(doc->url()), DoUpdate | DoEmit);
 }
 
-ProblemScope OpenDocumentSet::getScope() const
+ProblemScope OpenDocumentSet::scope() const
 {
     return OpenDocuments;
 }
 
 ProjectSet::ProjectSet(QObject* parent)
     : WatchedDocumentSet(parent)
 {
 }
 
 void ProjectSet::fileAdded(ProjectFileItem* file)
 {
     d->addDocument(IndexedString(file->indexedPath()), DoUpdate | DoEmit);
 }
 
 void ProjectSet::fileRemoved(ProjectFileItem* file)
 {
     d->delDocument(IndexedString(file->indexedPath()), DoUpdate | DoEmit);
 }
 
 void ProjectSet::fileRenamed(const Path& oldFile, ProjectFileItem* newFile)
 {
     d->delDocument(IndexedString(oldFile.pathOrUrl()));
     d->addDocument(IndexedString(newFile->indexedPath()), DoUpdate | DoEmit);
 }
 
 void ProjectSet::trackProjectFiles(const IProject* project)
 {
     if (project) {
         // The implementation should derive from QObject somehow
         QObject* fileManager = dynamic_cast<QObject*>(project->projectFileManager());
         if (fileManager) {
             // can't use new signal/slot syntax here, IProjectFileManager is no a QObject
             connect(fileManager, SIGNAL(fileAdded(ProjectFileItem*)),
                     this, SLOT(fileAdded(ProjectFileItem*)));
             connect(fileManager, SIGNAL(fileRemoved(ProjectFileItem*)),
                     this, SLOT(fileRemoved(ProjectFileItem*)));
             connect(fileManager, SIGNAL(fileRenamed(Path,ProjectFileItem*)),
                     this, SLOT(fileRenamed(Path,ProjectFileItem*)));
         }
     }
 }
 
 CurrentProjectSet::CurrentProjectSet(const IndexedString& document, QObject* parent)
     : ProjectSet(parent)
     , m_currentProject(nullptr)
 {
     setCurrentDocumentInternal(document);
 }
 
 void CurrentProjectSet::setCurrentDocument(const IndexedString& url)
 {
     setCurrentDocumentInternal(url);
 }
 
 void CurrentProjectSet::setCurrentDocumentInternal(const IndexedString& url)
 {
     IProject* projectForUrl = ICore::self()->projectController()->findProjectForUrl(url.toUrl());
     if (projectForUrl && projectForUrl != m_currentProject) {
         m_currentProject = projectForUrl;
         d->setDocuments(m_currentProject->fileSet());
         d->addDocument(IndexedString(m_currentProject->path().toLocalFile()), DoUpdate | DoEmit);
         trackProjectFiles(m_currentProject);
     }
 }
 
-ProblemScope CurrentProjectSet::getScope() const
+ProblemScope CurrentProjectSet::scope() const
 {
     return CurrentProject;
 }
 
 AllProjectSet::AllProjectSet(QObject* parent)
     : ProjectSet(parent)
 {
     foreach(const IProject* project, ICore::self()->projectController()->projects()) {
         foreach (const IndexedString &indexedString, project->fileSet()) {
             d->addDocument(indexedString);
         }
         d->addDocument(IndexedString(project->path().toLocalFile()));
         trackProjectFiles(project);
     }
     d->updateImports();
     emit changed();
 }
 
-ProblemScope AllProjectSet::getScope() const
+ProblemScope AllProjectSet::scope() const
 {
     return AllProjects;
 }
 
 BypassSet::BypassSet(QObject* parent)
     : WatchedDocumentSet(parent)
 {
 }
 
-ProblemScope BypassSet::getScope() const
+ProblemScope BypassSet::scope() const
 {
     return BypassScopeFilter;
 }
 
 }
 
 #include "watcheddocumentset.moc"
diff --git a/kdevplatform/shell/watcheddocumentset.h b/kdevplatform/shell/watcheddocumentset.h
index 57546e63ff..342a1b8a4f 100644
--- a/kdevplatform/shell/watcheddocumentset.h
+++ b/kdevplatform/shell/watcheddocumentset.h
@@ -1,149 +1,149 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2010 Dmitry Risenberg <dmitry.risenberg@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef KDEVPLATFORM_PLUGIN_WATCHEDDOCUMENTSET_H
 #define KDEVPLATFORM_PLUGIN_WATCHEDDOCUMENTSET_H
 
 #include <QObject>
 #include <QSet>
 
 #include <serialization/indexedstring.h>
 #include <shell/shellexport.h>
 
 #include "problemconstants.h"
 
 namespace KDevelop {
 class IDocument;
 class IProject;
 class ProjectFileItem;
 class Path;
 
 /**
  * Helper class that tracks set of documents and notifies its owner whenever this set changes. Derived classes implement different tracking strategies.
  */
 class KDEVPLATFORMSHELL_EXPORT WatchedDocumentSet : public QObject
 {
     Q_OBJECT
 public:
     using DocumentSet = QSet<IndexedString>;
 
     explicit WatchedDocumentSet(QObject* parent);
     ~WatchedDocumentSet() override;
 
     bool showImports() const;
     void setShowImports(bool showImports);
 
     virtual DocumentSet get() const;
-    virtual DocumentSet getImports() const;
+    virtual DocumentSet imports() const;
 
     virtual void setCurrentDocument(const IndexedString& url);
-    virtual ProblemScope getScope() const = 0;
+    virtual ProblemScope scope() const = 0;
 
 Q_SIGNALS:
     void changed();
 
 protected:
     const QScopedPointer<class WatchedDocumentSetPrivate> d;
 };
 
 /**
  * Tracks a document that is current at any given moment.
  * When a new file is activated, it becomes tracked instead of the old one.
  */
 class CurrentDocumentSet : public WatchedDocumentSet
 {
     Q_OBJECT
 public:
     explicit CurrentDocumentSet(const IndexedString& document, QObject* parent);
     void setCurrentDocument(const IndexedString& url) override;
-    ProblemScope getScope() const override;
+    ProblemScope scope() const override;
 };
 
 /**
  * Tracks all open documents.
  */
 class OpenDocumentSet : public WatchedDocumentSet
 {
     Q_OBJECT
 public:
     explicit OpenDocumentSet(QObject* parent);
-    ProblemScope getScope() const override;
+    ProblemScope scope() const override;
 
 private Q_SLOTS:
     void documentClosed(IDocument* doc);
     void documentCreated(IDocument* doc);
 };
 
 /**
  * Tracks documents that are in the same project as the current file.
  * If current file is not in any project, none are tracked.
  */
 class ProjectSet : public WatchedDocumentSet
 {
     Q_OBJECT
 public:
     explicit ProjectSet(QObject* parent);
 
 protected:
     void trackProjectFiles(const IProject* project);
 
 protected Q_SLOTS:
     void fileAdded(ProjectFileItem*);
     void fileRemoved(ProjectFileItem* file);
     void fileRenamed(const Path& oldFile, ProjectFileItem* newFile);
 };
 
 /**
  * Tracks files in all open projects.
  */
 class CurrentProjectSet : public ProjectSet
 {
     Q_OBJECT
 public:
     explicit CurrentProjectSet(const IndexedString& document, QObject* parent);
     void setCurrentDocument(const IndexedString& url) override;
-    ProblemScope getScope() const override;
+    ProblemScope scope() const override;
 
 private:
     void setCurrentDocumentInternal(const IndexedString& url); // to avoid virtual in constructor
     IProject* m_currentProject;
 };
 
 class AllProjectSet : public ProjectSet
 {
     Q_OBJECT
 public:
     explicit AllProjectSet(QObject* parent);
-    ProblemScope getScope() const override;
+    ProblemScope scope() const override;
 };
 
 class BypassSet : public WatchedDocumentSet
 {
     Q_OBJECT
 public:
     explicit BypassSet(QObject* parent);
 
-    ProblemScope getScope() const override;
+    ProblemScope scope() const override;
 };
 
 }
 
 #endif // KDEVPLATFORM_PLUGIN_WATCHEDDOCUMENTSET_H
diff --git a/kdevplatform/shell/workingsetcontroller.cpp b/kdevplatform/shell/workingsetcontroller.cpp
index f007c37394..48d3cd2d7b 100644
--- a/kdevplatform/shell/workingsetcontroller.cpp
+++ b/kdevplatform/shell/workingsetcontroller.cpp
@@ -1,317 +1,317 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "workingsetcontroller.h"
 
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include "mainwindow.h"
 #include "partdocument.h"
 #include "uicontroller.h"
 
 #include <interfaces/iuicontroller.h>
 #include <interfaces/isession.h>
 
 #include <sublime/view.h>
 #include <sublime/area.h>
 
 #include <util/activetooltip.h>
 
 #include "workingsets/workingset.h"
 #include "workingsets/workingsettooltipwidget.h"
 #include "workingsets/workingsetwidget.h"
 #include "workingsets/closedworkingsetswidget.h"
 #include "core.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 const int toolTipTimeout = 2000;
 
 WorkingSetController::WorkingSetController()
 {
     m_hideToolTipTimer = new QTimer(this);
     m_hideToolTipTimer->setInterval(toolTipTimeout);
     m_hideToolTipTimer->setSingleShot(true);
 }
 
 void WorkingSetController::initialize()
 {
     //Load all working-sets
     KConfigGroup setConfig(Core::self()->activeSession()->config(), "Working File Sets");
     foreach(const QString& set, setConfig.groupList()) {
         // do not load working set if the id contains an '|', because it then belongs to an area.
         // this is functionally equivalent to the if ( ! config->icon ) stuff which was there before.
         if (set.contains(QLatin1Char('|'))) {
             continue;
         }
-        getWorkingSet(set);
+        workingSet(set);
     }
 
     m_emptyWorkingSet = new WorkingSet(QStringLiteral("empty"));
 
     if(!(Core::self()->setupFlags() & Core::NoUi)) {
         setupActions();
     }
 }
 
 void WorkingSetController::cleanup()
 {
     foreach(Sublime::MainWindow* window, Core::self()->uiControllerInternal()->mainWindows()) {
         foreach (Sublime::Area *area, window->areas()) {
             if (!area->workingSet().isEmpty()) {
                 Q_ASSERT(m_workingSets.contains(area->workingSet()));
                 m_workingSets[area->workingSet()]->saveFromArea(area, area->rootIndex());
             }
         }
     }
 
     foreach(WorkingSet* set, m_workingSets) {
         qCDebug(SHELL) << "set" << set->id() << "persistent" << set->isPersistent() << "has areas:" << set->hasConnectedAreas() << "files" << set->fileList();
         if(!set->isPersistent() && !set->hasConnectedAreas()) {
             qCDebug(SHELL) << "deleting";
             set->deleteSet(true, true);
         }
         delete set;
     }
 
     m_workingSets.clear();
 
     delete m_emptyWorkingSet;
     m_emptyWorkingSet = nullptr;
 }
 
 const QString WorkingSetController::makeSetId(const QString& prefix) const
 {
     QString newId;
     const uint maxRetries = 10;
     for(uint retry = 2; retry <= maxRetries; retry++) {
         newId = QStringLiteral("%1_%2").arg(prefix).arg(qrand() % 10000000);
         WorkingSetIconParameters params(newId);
         for (WorkingSet* set : m_workingSets) {
             if(set->isEmpty()) {
                 continue;
             }
             // The last retry will always generate a valid set
             if(retry != maxRetries && WorkingSetIconParameters(set->id()).similarity(params) >= retry*8) {
                 newId = QString();
                 break;
             }
         }
         if(! newId.isEmpty()) {
             break;
         }
     }
     return newId;
 }
 
 WorkingSet* WorkingSetController::newWorkingSet(const QString& prefix)
 {
-    return getWorkingSet(makeSetId(prefix));
+    return workingSet(makeSetId(prefix));
 }
 
-WorkingSet* WorkingSetController::getWorkingSet(const QString& id)
+WorkingSet* WorkingSetController::workingSet(const QString& id)
 {
     if(id.isEmpty())
         return m_emptyWorkingSet;
 
     if(!m_workingSets.contains(id)) {
         WorkingSet* set = new WorkingSet(id);
         connect(set, &WorkingSet::aboutToRemove,
                 this, &WorkingSetController::aboutToRemoveWorkingSet);
         m_workingSets[id] = set;
         emit workingSetAdded(set);
     }
 
     return m_workingSets[id];
 }
 
 QWidget* WorkingSetController::createSetManagerWidget(MainWindow* parent, Sublime::Area* fixedArea) {
     if (fixedArea) {
         return new WorkingSetWidget(fixedArea, parent);
     } else {
         return new ClosedWorkingSetsWidget(parent);
     }
 }
 
 void WorkingSetController::setupActions()
 {
 }
 
 ActiveToolTip* WorkingSetController::tooltip() const
 {
     return m_tooltip;
 }
 
 void WorkingSetController::showToolTip(WorkingSet* set, const QPoint& pos)
 {
     delete m_tooltip;
 
     KDevelop::MainWindow* window = static_cast<KDevelop::MainWindow*>(Core::self()->uiControllerInternal()->activeMainWindow());
 
     m_tooltip = new KDevelop::ActiveToolTip(window, pos);
     QVBoxLayout* layout = new QVBoxLayout(m_tooltip);
     layout->setMargin(0);
     WorkingSetToolTipWidget* widget = new WorkingSetToolTipWidget(m_tooltip, set, window);
     layout->addWidget(widget);
     m_tooltip->resize( m_tooltip->sizeHint() );
 
     connect(widget, &WorkingSetToolTipWidget::shouldClose, m_tooltip.data(), &ActiveToolTip::close);
 
     ActiveToolTip::showToolTip(m_tooltip);
 }
 
 void WorkingSetController::showGlobalToolTip()
 {
     KDevelop::MainWindow* window = static_cast<KDevelop::MainWindow*>(Core::self()->uiControllerInternal()->activeMainWindow());
 
-    showToolTip(getWorkingSet(window->area()->workingSet()),
+    showToolTip(workingSet(window->area()->workingSet()),
                               window->mapToGlobal(window->geometry().topRight()));
 
     connect(m_hideToolTipTimer, &QTimer::timeout,  m_tooltip.data(), &ActiveToolTip::deleteLater);
     m_hideToolTipTimer->start();
     connect(m_tooltip.data(), &ActiveToolTip::mouseIn, m_hideToolTipTimer, &QTimer::stop);
     connect(m_tooltip.data(), &ActiveToolTip::mouseOut, m_hideToolTipTimer, static_cast<void(QTimer::*)()>(&QTimer::start));
 }
 
 WorkingSetToolTipWidget* WorkingSetController::workingSetToolTip()
 {
     if(!m_tooltip)
         showGlobalToolTip();
 
     m_hideToolTipTimer->start();
 
     if(m_tooltip)
     {
         WorkingSetToolTipWidget* widget = m_tooltip->findChild<WorkingSetToolTipWidget*>();
         Q_ASSERT(widget);
         return widget;
     }
     return nullptr;
 }
 
 void WorkingSetController::nextDocument()
 {
     auto widget = workingSetToolTip();
     if (widget) {
         widget->nextDocument();
     }
 }
 
 void WorkingSetController::previousDocument()
 {
     auto widget = workingSetToolTip();
     if (widget) {
         widget->previousDocument();
     }
 }
 
 void WorkingSetController::initializeController( UiController* controller )
 {
   connect( controller, &UiController::areaCreated, this, &WorkingSetController::areaCreated );
 }
 
 QList< WorkingSet* > WorkingSetController::allWorkingSets() const
 {
   return m_workingSets.values();
 }
 
 void WorkingSetController::areaCreated( Sublime::Area* area )
 {
     if (!area->workingSet().isEmpty()) {
-        WorkingSet* set = getWorkingSet( area->workingSet() );
+        WorkingSet* set = workingSet( area->workingSet() );
         set->connectArea( area );
     }
 
     connect(area, &Sublime::Area::changingWorkingSet,
             this, &WorkingSetController::changingWorkingSet);
     connect(area, &Sublime::Area::changedWorkingSet,
             this, &WorkingSetController::changedWorkingSet);
     connect(area, &Sublime::Area::viewAdded,
             this, &WorkingSetController::viewAdded);
     connect(area, &Sublime::Area::clearWorkingSet,
             this, &WorkingSetController::clearWorkingSet);
 }
 
 void WorkingSetController::changingWorkingSet(Sublime::Area* area, const QString& from, const QString& to)
 {
     qCDebug(SHELL) << "changing working-set from" << from << "to" << to << "area" << area;
     if (from == to)
         return;
 
     if (!from.isEmpty()) {
-        WorkingSet* oldSet = getWorkingSet(from);
+        WorkingSet* oldSet = workingSet(from);
         oldSet->disconnectArea(area);
         if (!oldSet->id().isEmpty()) {
             oldSet->saveFromArea(area, area->rootIndex());
         }
     }
 }
 
 void WorkingSetController::changedWorkingSet(Sublime::Area* area, const QString& from, const QString& to)
 {
     qCDebug(SHELL) << "changed working-set from" << from << "to" << to << "area" << area;
     if (from == to || m_changingWorkingSet)
         return;
 
     if (!to.isEmpty()) {
-        WorkingSet* newSet = getWorkingSet(to);
+        WorkingSet* newSet = workingSet(to);
         newSet->connectArea(area);
         newSet->loadToArea(area, area->rootIndex());
     }else{
         // Clear silently, any user-interaction should have happened before
         area->clearViews(true);
     }
 
     emit workingSetSwitched();
 }
 
 void WorkingSetController::viewAdded( Sublime::AreaIndex* , Sublime::View* )
 {
     Sublime::Area* area = qobject_cast< Sublime::Area* >(sender());
     Q_ASSERT(area);
 
     if (area->workingSet().isEmpty()) {
         //Spawn a new working-set
         m_changingWorkingSet = true;
         WorkingSet* set = Core::self()->workingSetControllerInternal()->newWorkingSet(area->objectName());
         qCDebug(SHELL) << "Spawned new working-set" << set->id() << "because a view was added";
         set->connectArea(area);
         set->saveFromArea(area, area->rootIndex());
         area->setWorkingSet(set->id());
         m_changingWorkingSet = false;
     }
 }
 
 void WorkingSetController::clearWorkingSet(Sublime::Area * area)
 {
-    const QString workingSet = area->workingSet();
-    if (workingSet.isEmpty()) {
+    const QString workingSetId = area->workingSet();
+    if (workingSetId.isEmpty()) {
         // Nothing to do - area has no working set
         return;
     }
 
-    WorkingSet* set = getWorkingSet(workingSet);
+    WorkingSet* set = workingSet(workingSetId);
     set->deleteSet(true);
 
-    WorkingSet* newSet = getWorkingSet(workingSet);
+    WorkingSet* newSet = workingSet(workingSetId);
     newSet->connectArea(area);
     newSet->loadToArea(area, area->rootIndex());
     Q_ASSERT(newSet->fileList().isEmpty());
 }
diff --git a/kdevplatform/shell/workingsetcontroller.h b/kdevplatform/shell/workingsetcontroller.h
index 90cf4cb709..2b0b709ce3 100644
--- a/kdevplatform/shell/workingsetcontroller.h
+++ b/kdevplatform/shell/workingsetcontroller.h
@@ -1,127 +1,127 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #ifndef KDEVPLATFORM_WORKINGSETCONTROLLER_H
 #define KDEVPLATFORM_WORKINGSETCONTROLLER_H
 
 #include <QObject>
 #include <QSet>
 #include <QMap>
 #include <QPointer>
 
 class QPoint;
 class QWidget;
 class QTimer;
 
 namespace Sublime {
 class Area;
 class AreaIndex;
 class View;
 }
 
 namespace KDevelop {
 
 class ActiveToolTip;
 class UiController;
 class MainWindow;
 class Core;
 
 class WorkingSet;
 class WorkingSetToolTipWidget;
 
 class WorkingSetController : public QObject
 {
     Q_OBJECT
 
 public:
     WorkingSetController();
     void initialize();
     void cleanup();
 
     ///Returns a working-set management widget
 //     QWidget* createManagerWidget(QObject* parent);
 
     WorkingSet* newWorkingSet(const QString& prefix);
 
     /**
      * Get WorkingSet for given @p id.
      *
      * NOTE: Never pass an empty @p id, this means there is no working set
      *       for the given area you got that @p id from.
      */
-    WorkingSet* getWorkingSet(const QString& id);
+    WorkingSet* workingSet(const QString& id);
 
     QList<WorkingSet*> allWorkingSets() const;
 
     //The returned widget is owned by the caller
     QWidget* createSetManagerWidget(MainWindow* parent, Sublime::Area* fixedArea = nullptr);
 
     void initializeController(UiController* controller);
 
     KDevelop::ActiveToolTip* tooltip() const;
     void showToolTip( KDevelop::WorkingSet* set, const QPoint& pos);
 
 Q_SIGNALS:
     void workingSetAdded(WorkingSet* set);
     void aboutToRemoveWorkingSet(WorkingSet* set);
     // Emitted after a working-set in a main-window was switched
     void workingSetSwitched();
 
 private Q_SLOTS:
     void areaCreated(Sublime::Area* area);
 
     void nextDocument();
     void previousDocument();
     void showGlobalToolTip();
 
     /**
      * Disconnect @p oldSet from @p area and save it. Connect @p newSet with @p area.
      */
     void changingWorkingSet( Sublime::Area* area, const QString& oldSet, const QString& newSet);
     /**
      * Notify about working set change and setup @p area with contents of @p newSet.
      */
     void changedWorkingSet( Sublime::Area* area, const QString& oldSet, const QString& newSet );
     /**
      * Spawn new WorkingSet when we don't have one already for the view.
      */
     void viewAdded( Sublime::AreaIndex*, Sublime::View* );
 
     /**
      * Clears the files in the working set
      */
     void clearWorkingSet(Sublime::Area* area);
 
 private:
     WorkingSetToolTipWidget* workingSetToolTip();
     void setupActions();
     const QString makeSetId(const QString& prefix) const;
 
     QSet<QString> m_usedIcons;
     QMap<QString, WorkingSet*> m_workingSets;
     WorkingSet* m_emptyWorkingSet = nullptr;
     QTimer* m_hideToolTipTimer;
     QPointer<KDevelop::ActiveToolTip> m_tooltip;
     // This is set to true while the working-set controller is forcing a working-set
     // onto an area. We ignore the low-level feedback then, as we handle the switch on a higher level.
     bool m_changingWorkingSet = false;
 };
 
 }
 
 #endif // KDEVPLATFORM_WORKINGSETMANAGER_H
diff --git a/kdevplatform/shell/workingsets/closedworkingsetswidget.cpp b/kdevplatform/shell/workingsets/closedworkingsetswidget.cpp
index 5e12234d20..483edf1dcc 100644
--- a/kdevplatform/shell/workingsets/closedworkingsetswidget.cpp
+++ b/kdevplatform/shell/workingsets/closedworkingsetswidget.cpp
@@ -1,131 +1,131 @@
 /***************************************************************************
  *   This file is part of KDevelop                                         *
  *   Copyright 2010 Milian Wolff <mail@milianw.de>                         *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU Library General Public License as       *
  *   published by the Free Software Foundation; either version 2 of the    *
  *   License, or (at your option) any later version.                       *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU Library General Public     *
  *   License along with this program; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
 
 #include "closedworkingsetswidget.h"
 
 #include <sublime/area.h>
 
 #include <shell/core.h>
 
 #include "mainwindow.h"
 #include "workingsetcontroller.h"
 
 #include "workingset.h"
 #include "workingsettoolbutton.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
-WorkingSet* getWorkingSet(const QString& id)
+WorkingSet* workingSet(const QString& id)
 {
-    return Core::self()->workingSetControllerInternal()->getWorkingSet(id);
+    return Core::self()->workingSetControllerInternal()->workingSet(id);
 }
 
 ClosedWorkingSetsWidget::ClosedWorkingSetsWidget( MainWindow* window )
     : QWidget(nullptr), m_mainWindow(window)
 {
     connect(window, &MainWindow::areaChanged,
             this, &ClosedWorkingSetsWidget::areaChanged);
 
     m_layout = new QHBoxLayout(this);
     m_layout->setMargin(0);
 
     if (window->area()) {
         areaChanged(window->area());
     }
 
     connect(Core::self()->workingSetControllerInternal(), &WorkingSetController::aboutToRemoveWorkingSet,
             this, &ClosedWorkingSetsWidget::removeWorkingSet);
 
     connect(Core::self()->workingSetControllerInternal(), &WorkingSetController::workingSetAdded,
             this, &ClosedWorkingSetsWidget::addWorkingSet);
 }
 
 void ClosedWorkingSetsWidget::areaChanged( Sublime::Area* area )
 {
     if (m_connectedArea) {
         disconnect(area, &Sublime::Area::changedWorkingSet,
                    this, &ClosedWorkingSetsWidget::changedWorkingSet);
     }
 
     m_connectedArea = area;
     connect(m_connectedArea.data(), &Sublime::Area::changedWorkingSet,
             this, &ClosedWorkingSetsWidget::changedWorkingSet);
 
     // clear layout
     qDeleteAll(m_buttons);
     m_buttons.clear();
 
     // add sets from new area
     foreach(WorkingSet* set, Core::self()->workingSetControllerInternal()->allWorkingSets()) {
         addWorkingSet(set);
     }
 }
 
 void ClosedWorkingSetsWidget::changedWorkingSet( Sublime::Area* area, const QString& from, const QString& to )
 {
     Q_ASSERT(area == m_connectedArea);
     Q_UNUSED(area);
 
     if (!from.isEmpty()) {
-        WorkingSet* oldSet = getWorkingSet(from);
+        WorkingSet* oldSet = workingSet(from);
         addWorkingSet(oldSet);
     }
 
     if (!to.isEmpty()) {
-        WorkingSet* newSet = getWorkingSet(to);
+        WorkingSet* newSet = workingSet(to);
         removeWorkingSet(newSet);
     }
 }
 
 void ClosedWorkingSetsWidget::removeWorkingSet( WorkingSet* set )
 {
     delete m_buttons.take(set);
     Q_ASSERT(m_buttons.size() == m_layout->count());
     setVisible(!m_buttons.isEmpty());
 }
 
 void ClosedWorkingSetsWidget::addWorkingSet( WorkingSet* set )
 {
     if (m_buttons.contains(set)) {
         return;
     }
 
     // Don't show working-sets that are active in an area belong to this main-window, as those
     // can be activated directly through the icons in the tabs
     if (set->hasConnectedAreas(m_mainWindow->areas())) {
         return;
     }
 
     if (set->isEmpty()) {
 //             qCDebug(SHELL) << "skipping" << set->id() << "because empty";
         return;
     }
 
 //     qCDebug(SHELL) << "adding button for" << set->id();
     WorkingSetToolButton* button = new WorkingSetToolButton(this, set);
     button->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));
 
     m_layout->addWidget(button);
     m_buttons[set] = button;
     setVisible(!m_buttons.isEmpty());
 }
 
diff --git a/kdevplatform/shell/workingsets/workingsettoolbutton.cpp b/kdevplatform/shell/workingsets/workingsettoolbutton.cpp
index 27459d8316..afc4bb975c 100644
--- a/kdevplatform/shell/workingsets/workingsettoolbutton.cpp
+++ b/kdevplatform/shell/workingsets/workingsettoolbutton.cpp
@@ -1,175 +1,175 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "workingsettoolbutton.h"
 
 #include <QContextMenuEvent>
 
 #include <sublime/mainwindow.h>
 #include <sublime/area.h>
 
 #include "core.h"
 #include "mainwindow.h"
 #include "workingset.h"
 #include "workingsetcontroller.h"
 #include "workingsethelpers.h"
 #include "documentcontroller.h"
 
 #include <interfaces/idocumentcontroller.h>
 #include <util/activetooltip.h>
 
 using namespace KDevelop;
 
 WorkingSetToolButton::WorkingSetToolButton(QWidget* parent, WorkingSet* set)
     : QToolButton(parent), m_set(set), m_toolTipEnabled(true)
 {
     setFocusPolicy(Qt::NoFocus);
     setWorkingSet(set);
     setAutoRaise(true);
 
     connect(this, &WorkingSetToolButton::clicked, this, &WorkingSetToolButton::buttonTriggered);
 }
 
 WorkingSet* WorkingSetToolButton::workingSet() const
 {
     return m_set;
 }
 
 void WorkingSetToolButton::setWorkingSet(WorkingSet* set)
 {
     m_set = set;
 
     setIcon(set ? set->icon() : QIcon());
 }
 
 void WorkingSetToolButton::contextMenuEvent(QContextMenuEvent* ev)
 {
     showTooltip(ev->globalPos());
 
     ev->accept();
 }
 
 void WorkingSetToolButton::intersectSet()
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
 
-    filterViews(Core::self()->workingSetControllerInternal()->getWorkingSet(mainWindow()->area()->workingSet())->fileList().toSet() & m_set->fileList().toSet());
+    filterViews(Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileList().toSet() & m_set->fileList().toSet());
 }
 
 void WorkingSetToolButton::subtractSet()
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
 
-    filterViews(Core::self()->workingSetControllerInternal()->getWorkingSet(mainWindow()->area()->workingSet())->fileList().toSet() - m_set->fileList().toSet());
+    filterViews(Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileList().toSet() - m_set->fileList().toSet());
 }
 
 void WorkingSetToolButton::mergeSet()
 {
     Q_ASSERT(m_set);
 
-    const QSet<QString> loadFiles = m_set->fileList().toSet() - Core::self()->workingSetControllerInternal()->getWorkingSet(mainWindow()->area()->workingSet())->fileList().toSet();
+    const QSet<QString> loadFiles = m_set->fileList().toSet() - Core::self()->workingSetControllerInternal()->workingSet(mainWindow()->area()->workingSet())->fileList().toSet();
     for (const QString& file : loadFiles) {
         Core::self()->documentController()->openDocument(QUrl::fromUserInput(file));
     }
 }
 
 void WorkingSetToolButton::duplicateSet()
 {
     Q_ASSERT(m_set);
 
     if(!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
         return;
     WorkingSet* set = Core::self()->workingSetControllerInternal()->newWorkingSet(QStringLiteral("clone"));
     set->setPersistent(true);
     set->saveFromArea(mainWindow()->area(), mainWindow()->area()->rootIndex());
     mainWindow()->area()->setWorkingSet(set->id());
 }
 
 void WorkingSetToolButton::loadSet()
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
 
     if(!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
         return;
     mainWindow()->area()->setWorkingSet(QString(m_set->id()));
 }
 
 void WorkingSetToolButton::closeSet(bool ask)
 {
     Q_ASSERT(m_set);
 
     m_set->setPersistent(true);
     m_set->saveFromArea(mainWindow()->area(), mainWindow()->area()->rootIndex());
 
     if(ask && !Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
         return;
     mainWindow()->area()->setWorkingSet(QString());
 }
 
 bool WorkingSetToolButton::event(QEvent* e)
 {
     if(m_toolTipEnabled && e->type() == QEvent::ToolTip) {
         QHelpEvent* helpEvent = static_cast<QHelpEvent*>(e);
         showTooltip(helpEvent->globalPos());
         e->accept();
         return true;
     }
 
     return QToolButton::event(e);
 }
 
 void WorkingSetToolButton::showTooltip(const QPoint& globalPos)
 {
     Q_ASSERT(m_set);
     static WorkingSetToolButton* oldTooltipButton;
 
     WorkingSetController* controller = Core::self()->workingSetControllerInternal();
 
     if(controller->tooltip() && oldTooltipButton == this)
         return;
 
     oldTooltipButton = this;
 
     controller->showToolTip(m_set, globalPos + QPoint(10, 20));
 
     QRect extended(parentWidget()->mapToGlobal(geometry().topLeft()),
                     parentWidget()->mapToGlobal(geometry().bottomRight()));
     controller->tooltip()->setHandleRect(extended);
 }
 
 void WorkingSetToolButton::buttonTriggered()
 {
     Q_ASSERT(m_set);
 
     if(mainWindow()->area()->workingSet() == m_set->id()) {
         showTooltip(QCursor::pos());
     }else{
         //Only close the working-set if the file was saved before
         if(!Core::self()->documentControllerInternal()->saveAllDocumentsForWindow(mainWindow(), KDevelop::IDocument::Default, true))
             return;
         m_set->setPersistent(true);
         mainWindow()->area()->setWorkingSet(m_set->id());
     }
 }
 
diff --git a/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp b/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp
index 2f7e5f57a6..85541a5a1b 100644
--- a/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp
+++ b/kdevplatform/shell/workingsets/workingsettooltipwidget.cpp
@@ -1,392 +1,392 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "workingsettooltipwidget.h"
 
 #include <KLocalizedString>
 
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include "debug.h"
 #include "core.h"
 #include "documentcontroller.h"
 #include "mainwindow.h"
 
 #include <sublime/view.h>
 #include <sublime/mainwindow.h>
 #include <sublime/area.h>
 #include <sublime/document.h>
 
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <util/activetooltip.h>
 
 #include "workingset.h"
 #include "workingsetcontroller.h"
 #include "workingsetfilelabel.h"
 #include "workingsettoolbutton.h"
 #include "workingsethelpers.h"
 
 using namespace KDevelop;
 
 class FileWidget : public QWidget
 {
     Q_OBJECT
 
 public:
     QToolButton* m_button;
     class WorkingSetFileLabel* m_label;
 };
 
 WorkingSetToolTipWidget::WorkingSetToolTipWidget(QWidget* parent, WorkingSet* set, MainWindow* mainwindow) : QWidget(parent), m_set(set) {
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->setSpacing(0);
 
     layout->setMargin(0);
 
     connect(static_cast<Sublime::MainWindow*>(mainwindow)->area(),
             &Sublime::Area::viewAdded, this, &WorkingSetToolTipWidget::updateFileButtons,
             Qt::QueuedConnection);
     connect(static_cast<Sublime::MainWindow*>(mainwindow)->area(),
             &Sublime::Area::viewRemoved, this, &WorkingSetToolTipWidget::updateFileButtons,
             Qt::QueuedConnection);
 
     connect(Core::self()->workingSetControllerInternal(), &WorkingSetController::workingSetSwitched,
             this, &WorkingSetToolTipWidget::updateFileButtons);
 
     // title bar
     {
         QHBoxLayout* topLayout = new QHBoxLayout;
         m_setButton = new WorkingSetToolButton(this, set);
         m_setButton->hide();
 
         topLayout->addSpacing(5);
         QLabel* icon = new QLabel;
         topLayout->addWidget(icon);
         topLayout->addSpacing(5);
 
         QString label;
         if (m_set->isConnected(mainwindow->area())) {
             label = i18n("<b>Active Working Set</b>");
         } else {
             label = i18n("<b>Working Set</b>");
         }
         QLabel* name = new QLabel(label);
         name->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
         topLayout->addWidget(name);
          topLayout->addSpacing(10);
 
         icon->setPixmap(m_setButton->icon().pixmap(name->sizeHint().height()+8, name->sizeHint().height()+8));
 
         topLayout->addStretch();
 
         m_openButton = new QPushButton;
         m_openButton->setFlat(true);
         topLayout->addWidget(m_openButton);
 
         m_deleteButton = new QPushButton;
         m_deleteButton->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
         m_deleteButton->setText(i18n("Delete"));
         m_deleteButton->setToolTip(i18n("Remove this working set. The contained documents are not affected."));
         m_deleteButton->setFlat(true);
         connect(m_deleteButton, &QPushButton::clicked, m_set, [&] { m_set->deleteSet(false); });
         connect(m_deleteButton, &QPushButton::clicked, this, &WorkingSetToolTipWidget::shouldClose);
         topLayout->addWidget(m_deleteButton);
         layout->addLayout(topLayout);
         // horizontal line
         QFrame* line = new QFrame();
         line->setFrameShape(QFrame::HLine);
         line->setFrameShadow(QFrame::Raised);
         layout->addWidget(line);
     }
 
     // everything else is added to the following widget which just has a different background color
     QVBoxLayout* bodyLayout = new QVBoxLayout;
     {
         QWidget* body = new QWidget();
         body->setLayout(bodyLayout);
         layout->addWidget(body);
         body->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     }
 
     // document list actions
     {
         QHBoxLayout* actionsLayout = new QHBoxLayout;
 
         m_documentsLabel = new QLabel(i18n("Documents:"));
         m_documentsLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
         actionsLayout->addWidget(m_documentsLabel);
 
         actionsLayout->addStretch();
 
         m_mergeButton = new QPushButton;
         m_mergeButton->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
         m_mergeButton->setText(i18n("Add All"));
         m_mergeButton->setToolTip(i18n("Add all documents that are part of this working set to the currently active working set."));
         m_mergeButton->setFlat(true);
         connect(m_mergeButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::mergeSet);
         actionsLayout->addWidget(m_mergeButton);
 
         m_subtractButton = new QPushButton;
         m_subtractButton->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
         m_subtractButton->setText(i18n("Remove All"));
         m_subtractButton->setToolTip(i18n("Remove all documents that are part of this working set from the currently active working set."));
         m_subtractButton->setFlat(true);
         connect(m_subtractButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::subtractSet);
         actionsLayout->addWidget(m_subtractButton);
         bodyLayout->addLayout(actionsLayout);
     }
 
     QSet<QString> hadFiles;
 
     QVBoxLayout* filesLayout = new QVBoxLayout;
     filesLayout->setMargin(0);
 
     foreach(const QString& file, m_set->fileList()) {
 
         if(hadFiles.contains(file))
             continue;
 
         hadFiles.insert(file);
 
         FileWidget* widget = new FileWidget;
         widget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
 
         QHBoxLayout* fileLayout = new QHBoxLayout(widget);
 
         QToolButton* plusButton = new QToolButton;
         plusButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
         fileLayout->addWidget(plusButton);
 
         WorkingSetFileLabel* fileLabel = new WorkingSetFileLabel;
         fileLabel->setTextFormat(Qt::RichText);
         // We add spaces behind and after, to make it look nicer
         fileLabel->setText(QLatin1String("&nbsp;") + Core::self()->projectController()->prettyFileName(QUrl::fromUserInput(file)) + QLatin1String("&nbsp;"));
         fileLabel->setToolTip(i18nc("@info:tooltip", "Click to open and activate this document."));
         fileLabel->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
         fileLayout->addWidget(fileLabel);
         fileLayout->setMargin(0);
 
         plusButton->setMaximumHeight(fileLabel->sizeHint().height() + 4);
         plusButton->setMaximumWidth(plusButton->maximumHeight());
 
         plusButton->setObjectName(file);
         fileLabel->setObjectName(file);
         fileLabel->setCursor(QCursor(Qt::PointingHandCursor));
 
         widget->m_button = plusButton;
         widget->m_label = fileLabel;
 
         filesLayout->addWidget(widget);
         m_fileWidgets.insert(file, widget);
         m_orderedFileWidgets.push_back(widget);
 
         connect(plusButton, &QToolButton::clicked, this, &WorkingSetToolTipWidget::buttonClicked);
         connect(fileLabel, &WorkingSetFileLabel::clicked, this, &WorkingSetToolTipWidget::labelClicked);
     }
 
     bodyLayout->addLayout(filesLayout);
 
     updateFileButtons();
     connect(set, &WorkingSet::setChangedSignificantly, this, &WorkingSetToolTipWidget::updateFileButtons);
     connect(mainwindow->area(), &Sublime::Area::changedWorkingSet, this, &WorkingSetToolTipWidget::updateFileButtons, Qt::QueuedConnection);
 
     QMetaObject::invokeMethod(this, "updateFileButtons");
 }
 
 void WorkingSetToolTipWidget::nextDocument()
 {
     int active = -1;
     for(int a = 0; a < m_orderedFileWidgets.size(); ++a)
         if(m_orderedFileWidgets[a]->m_label->isActive())
             active = a;
 
     if(active == -1)
     {
         qCWarning(SHELL) << "Found no active document";
         return;
     }
 
     int next = (active + 1) % m_orderedFileWidgets.size();
     while(m_orderedFileWidgets[next]->isHidden() && next != active)
         next = (next + 1) % m_orderedFileWidgets.size();
 
     m_orderedFileWidgets[next]->m_label->emitClicked();
 }
 
 void WorkingSetToolTipWidget::previousDocument()
 {
     int active = -1;
     for(int a = 0; a < m_orderedFileWidgets.size(); ++a)
         if(m_orderedFileWidgets[a]->m_label->isActive())
             active = a;
 
     if(active == -1)
     {
         qCWarning(SHELL) << "Found no active document";
         return;
     }
 
     int next = active - 1;
     if(next < 0)
         next += m_orderedFileWidgets.size();
 
     while(m_orderedFileWidgets[next]->isHidden() && next != active)
     {
         next -= 1;
         if(next < 0)
             next += m_orderedFileWidgets.size();
     }
 
     m_orderedFileWidgets[next]->m_label->emitClicked();
 }
 
 
 void WorkingSetToolTipWidget::updateFileButtons()
 {
     MainWindow* mainWindow = dynamic_cast<MainWindow*>(Core::self()->uiController()->activeMainWindow());
     Q_ASSERT(mainWindow);
 
     WorkingSetController* controller = Core::self()->workingSetControllerInternal();
     ActiveToolTip* tooltip = controller->tooltip();
 
     QString activeFile;
     if(mainWindow->area()->activeView())
         activeFile = mainWindow->area()->activeView()->document()->documentSpecifier();
 
     WorkingSet* currentWorkingSet = nullptr;
     QSet<QString> openFiles;
 
     if(!mainWindow->area()->workingSet().isEmpty())
     {
-        currentWorkingSet = controller->getWorkingSet(mainWindow->area()->workingSet());
+        currentWorkingSet = controller->workingSet(mainWindow->area()->workingSet());
         openFiles = currentWorkingSet->fileList().toSet();
     }
 
     bool allOpen = true;
     bool noneOpen = true;
 
     bool needResize = false;
 
     bool allHidden = true;
 
     for(QMap< QString, FileWidget* >::iterator it = m_fileWidgets.begin(); it != m_fileWidgets.end(); ++it) {
         if(openFiles.contains(it.key())) {
             noneOpen = false;
             (*it)->m_button->setToolTip(i18n("Remove this file from the current working set"));
             (*it)->m_button->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
             (*it)->show();
         }else{
             allOpen = false;
             (*it)->m_button->setToolTip(i18n("Add this file to the current working set"));
             (*it)->m_button->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
             if(currentWorkingSet == m_set)
             {
                 (*it)->hide();
                 needResize = true;
             }
         }
 
 
         if(!(*it)->isHidden())
             allHidden = false;
 
         (*it)->m_label->setIsActiveFile(it.key() == activeFile);
     }
 
     // NOTE: always hide merge&subtract all on current working set
     // if we want to enable mergeButton, we have to fix it's behavior since it operates directly on the
     // set contents and not on the m_fileWidgets
     m_mergeButton->setHidden(allOpen || currentWorkingSet == m_set);
     m_subtractButton->setHidden(noneOpen || currentWorkingSet == m_set);
     m_deleteButton->setHidden(m_set->hasConnectedAreas());
     m_documentsLabel->setHidden(m_mergeButton->isHidden() && m_subtractButton->isHidden() && m_deleteButton->isHidden());
 
     if(currentWorkingSet == m_set) {
         disconnect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::loadSet);
         connect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::closeSet);
         connect(m_openButton, &QPushButton::clicked, this, &WorkingSetToolTipWidget::shouldClose);
         m_openButton->setIcon(QIcon::fromTheme(QStringLiteral("project-development-close")));
         m_openButton->setText(i18n("Stash"));
     }else{
         disconnect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::closeSet);
         connect(m_openButton, &QPushButton::clicked, m_setButton, &WorkingSetToolButton::loadSet);
         disconnect(m_openButton, &QPushButton::clicked, this, &WorkingSetToolTipWidget::shouldClose);
         m_openButton->setIcon(QIcon::fromTheme(QStringLiteral("project-open")));
         m_openButton->setText(i18n("Load"));
     }
 
     if(allHidden && tooltip)
         tooltip->hide();
 
     if(needResize && tooltip)
         tooltip->resize(tooltip->sizeHint());
 }
 
 void WorkingSetToolTipWidget::buttonClicked(bool)
 {
     QPointer<WorkingSetToolTipWidget> stillExists(this);
 
     QToolButton* s = qobject_cast<QToolButton*>(sender());
     Q_ASSERT(s);
 
     MainWindow* mainWindow = dynamic_cast<MainWindow*>(Core::self()->uiController()->activeMainWindow());
     Q_ASSERT(mainWindow);
-    QSet<QString> openFiles = Core::self()->workingSetControllerInternal()->getWorkingSet(mainWindow->area()->workingSet())->fileList().toSet();
+    QSet<QString> openFiles = Core::self()->workingSetControllerInternal()->workingSet(mainWindow->area()->workingSet())->fileList().toSet();
 
     if(!openFiles.contains(s->objectName())) {
         Core::self()->documentControllerInternal()->openDocument(QUrl::fromUserInput(s->objectName()));
     }else{
         openFiles.remove(s->objectName());
         filterViews(openFiles);
     }
 
     if(stillExists)
         updateFileButtons();
 }
 
 void WorkingSetToolTipWidget::labelClicked()
 {
     QPointer<WorkingSetToolTipWidget> stillExists(this);
 
     WorkingSetFileLabel* s = qobject_cast<WorkingSetFileLabel*>(sender());
     Q_ASSERT(s);
 
     bool found = false;
 
     Sublime::MainWindow* window = static_cast<Sublime::MainWindow*>(ICore::self()->uiController()->activeMainWindow());
 
     foreach(Sublime::View* view, window->area()->views())
     {
         if(view->document()->documentSpecifier() == s->objectName())
         {
             window->activateView(view);
             found = true;
             break;
         }
     }
 
     if(!found)
         Core::self()->documentControllerInternal()->openDocument(QUrl::fromUserInput(s->objectName()));
 
     if(stillExists)
         updateFileButtons();
 }
 
 #include "workingsettooltipwidget.moc"
diff --git a/kdevplatform/shell/workingsets/workingsetwidget.cpp b/kdevplatform/shell/workingsets/workingsetwidget.cpp
index c2ce12f828..1e09621010 100644
--- a/kdevplatform/shell/workingsets/workingsetwidget.cpp
+++ b/kdevplatform/shell/workingsets/workingsetwidget.cpp
@@ -1,89 +1,89 @@
 /*
     Copyright David Nolden  <david.nolden.kdevelop@art-master.de>
     Copyright 2010 Milian Wolff <mail@milianw.de>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "workingsetwidget.h"
 #include "debug.h"
 
 #include <sublime/area.h>
 
 #include "workingsetcontroller.h"
 #include "workingset.h"
 #include "workingsettoolbutton.h"
 
 #include <core.h>
 
 using namespace KDevelop;
 
 WorkingSet* getSet(const QString& id)
 {
     if (id.isEmpty()) {
         return nullptr;
     }
 
-    return Core::self()->workingSetControllerInternal()->getWorkingSet(id);
+    return Core::self()->workingSetControllerInternal()->workingSet(id);
 }
 
 WorkingSetWidget::WorkingSetWidget(Sublime::Area* area, QWidget* parent)
     : WorkingSetToolButton(parent, nullptr)
     , m_area(area)
 {
     //Queued connect so the change is already applied to the area when we start processing
     connect(m_area.data(), &Sublime::Area::changingWorkingSet, this,
             &WorkingSetWidget::changingWorkingSet, Qt::QueuedConnection);
 
     setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));
 
     changingWorkingSet(m_area, QString(), area->workingSet());
 }
 
 void WorkingSetWidget::setVisible( bool visible )
 {
     // never show empty working sets
     // TODO: I overloaded this only because hide() in the ctor does not work, other ideas?
     // It's not that it doesn't work from the constructor, it's that the value changes when the button is added on a layout.
     QWidget::setVisible( visible && (workingSet() && !workingSet()->isEmpty()) );
 }
 
 void WorkingSetWidget::changingWorkingSet( Sublime::Area* area, const QString& /*from*/, const QString& newSet)
 {
     qCDebug(SHELL) << "re-creating widget" << m_area;
 
     Q_ASSERT(area == m_area);
     Q_UNUSED(area);
 
     if (workingSet()) {
         disconnect(workingSet(), &WorkingSet::setChangedSignificantly,
                    this, &WorkingSetWidget::setChangedSignificantly);
     }
 
     WorkingSet* set = getSet(newSet);
     setWorkingSet(set);
 
     if (set) {
         connect(set, &WorkingSet::setChangedSignificantly,
                      this, &WorkingSetWidget::setChangedSignificantly);
     }
     setVisible(set && !set->isEmpty());
 }
 
 void WorkingSetWidget::setChangedSignificantly()
 {
     setVisible(!workingSet()->isEmpty());
 }
 
diff --git a/kdevplatform/template/filters/kdevfilters.cpp b/kdevplatform/template/filters/kdevfilters.cpp
index 8f6112691c..b1a9a22dc4 100644
--- a/kdevplatform/template/filters/kdevfilters.cpp
+++ b/kdevplatform/template/filters/kdevfilters.cpp
@@ -1,181 +1,181 @@
 /*  This file is part of KDevelop
     Copyright 2012 Miha Čančula <miha@noughmad.eu>
 
     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 "kdevfilters.h"
 
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 
 using namespace KDevelop;
 
 static
 QString safeString(const QVariant& variant)
 {
     if (variant.canConvert<Grantlee::SafeString>())
     {
         return variant.value<Grantlee::SafeString>().get();
     }
     else
     {
         return variant.toString();
     }
 }
 
 QStringList words(const QVariant& input)
 {
     QString string = safeString(input);
     if (string == string.toLower() && !string.contains(QLatin1Char('_'))) {
         return QStringList(string);
     }
 
     if (string.contains(QLatin1Char('_'))) {
         return string.toLower().split(QLatin1Char('_'));
     }
 
     int n = string.size();
     QStringList ret;
     int last = 0;
     for (int i = 1; i < n; ++i)
     {
         if (string[i].isUpper())
         {
             ret << string.mid(last, i-last).toLower();
             last = i;
         }
     }
     ret << string.mid(last).toLower();
     return ret;
 }
 
 QVariant CamelCaseFilter::doFilter(const QVariant& input, const QVariant& /*argument*/,
                                    bool /*autoescape*/) const
 {
     QString ret;
     foreach (const QString& word, words(input))
     {
         QString w = word;
         w[0] = w[0].toUpper();
         ret += w;
     }
     return Grantlee::SafeString(ret);
 }
 
 QVariant LowerCamelCaseFilter::doFilter(const QVariant& input, const QVariant& /*argument*/,
                                         bool /*autoescape*/) const
 {
     QString ret;
     foreach (const QString& word, words(input))
     {
         QString w = word;
         w[0] = w[0].toUpper();
         ret += w;
     }
     if (!ret.isEmpty())
     {
         ret[0] = ret[0].toUpper();
     }
     return Grantlee::SafeString(ret);
 }
 
 QVariant UnderscoreFilter::doFilter(const QVariant& input, const QVariant& /*argument*/,
                                     bool /*autoescape*/) const
 {
     QString ret = words(input).join(QLatin1Char('_'));
     return Grantlee::SafeString(ret);
 }
 
 QVariant UpperFirstFilter::doFilter(const QVariant& input, const QVariant& /*argument*/,
                                     bool /*autoescape*/) const
 {
     QString in = safeString(input);
     if (!in.isEmpty())
     {
         in[0] = in[0].toUpper();
     }
     return Grantlee::SafeString(in);
 }
 
 
 QVariant SplitLinesFilter::doFilter(const QVariant& input, const QVariant& argument,
                                     bool /*autoescape*/) const
 {
     QStringList retLines;
     QString start = safeString(argument);
     const auto lines = safeString(input).split(QLatin1Char('\n'), QString::KeepEmptyParts);
     retLines.reserve(lines.size());
     for (const auto& line : lines) {
         retLines << start + line;
     }
     return Grantlee::SafeString(retLines.join(QLatin1Char('\n')));
 }
 
 QVariant ArgumentTypeFilter::doFilter (const QVariant& input, const QVariant& /*argument*/,
                                        bool /*autoescape*/) const
 {
     QString type = safeString(input);
 
     DUChainReadLocker locker(DUChain::lock());
-    PersistentSymbolTable::Declarations decl = PersistentSymbolTable::self().getDeclarations(IndexedQualifiedIdentifier(QualifiedIdentifier(type)));
+    PersistentSymbolTable::Declarations decl = PersistentSymbolTable::self().declarations(IndexedQualifiedIdentifier(QualifiedIdentifier(type)));
 
     for(PersistentSymbolTable::Declarations::Iterator it = decl.iterator(); it; ++it)
     {
         DeclarationPointer declaration = DeclarationPointer(it->declaration());
         if(declaration->isForwardDeclaration())
         {
             continue;
         }
 
         // Check if it's a class/struct/etc
         if(declaration->type<StructureType>())
         {
             QString refType = QStringLiteral("const %1&").arg(type);
             return Grantlee::SafeString(refType);
         }
     }
 
     return Grantlee::SafeString(type);
 }
 
 KDevFilters::KDevFilters(QObject* parent, const QVariantList &)
 : QObject(parent)
 {
 }
 
 KDevFilters::~KDevFilters()
 {
 
 }
 
 QHash< QString, Grantlee::Filter* > KDevFilters::filters(const QString& name)
 {
     Q_UNUSED(name);
     QHash< QString, Grantlee::Filter* > filters;
 
     filters[QStringLiteral("camel_case")] = new CamelCaseFilter();
     filters[QStringLiteral("camel_case_lower")] = new LowerCamelCaseFilter();
     filters[QStringLiteral("underscores")] = new UnderscoreFilter();
     filters[QStringLiteral("lines_prepend")] = new SplitLinesFilter();
     filters[QStringLiteral("upper_first")] = new UpperFirstFilter();
     filters[QStringLiteral("arg_type")] = new ArgumentTypeFilter();
 
     return filters;
 }
diff --git a/kdevplatform/util/texteditorhelpers.cpp b/kdevplatform/util/texteditorhelpers.cpp
index 02c0530dbd..984cea8020 100644
--- a/kdevplatform/util/texteditorhelpers.cpp
+++ b/kdevplatform/util/texteditorhelpers.cpp
@@ -1,83 +1,83 @@
 /* This file is part of the KDE project
    Copyright 2015 Maciej Cencora
 
    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 "texteditorhelpers.h"
 
 #include <KTextEditor/View>
 
 #include <QRegularExpression>
 
 #include <cstdlib>
 
 namespace KDevelop {
 
 namespace {
 
 // TODO: this is a hack, but Kate does not provide interface for this
 int lineHeight(const KTextEditor::View* view, int curLine)
 {
   KTextEditor::Cursor c(curLine, 0);
   int currentHeight = view->cursorToCoordinate(c).y();
   c.setLine(curLine + 1);
   if (view->cursorToCoordinate(c).y() < 0) {
     c.setLine(curLine - 1);
   }
   return std::abs(view->cursorToCoordinate(c).y() - currentHeight);
 }
 
 }
 
-QRect KTextEditorHelpers::getItemBoundingRect(const KTextEditor::View* view, const KTextEditor::Range& itemRange)
+QRect KTextEditorHelpers::itemBoundingRect(const KTextEditor::View* view, const KTextEditor::Range& itemRange)
 {
   QPoint startPoint = view->mapToGlobal(view->cursorToCoordinate(itemRange.start()));
   QPoint endPoint = view->mapToGlobal(view->cursorToCoordinate(itemRange.end()));
   endPoint.ry() += lineHeight(view, itemRange.start().line());
   return QRect(startPoint, endPoint);
 }
 
 KTextEditor::Cursor KTextEditorHelpers::extractCursor(const QString& input, int* pathLength)
 {
     // ":ll:cc", ":ll"
     static const QRegularExpression pattern(QStringLiteral(":(\\d+)(?::(\\d+))?$"));
     // "#Lll", "#nll", "#ll" as e.g. seen with repo web links
     static const QRegularExpression pattern2(QStringLiteral("#(?:n|L|)(\\d+)$"));
 
     auto match = pattern.match(input);
 
     if (!match.hasMatch()) {
         match = pattern2.match(input);
     }
 
     if (!match.hasMatch()) {
         if (pathLength)
             *pathLength = input.length();
         return KTextEditor::Cursor::invalid();
     }
 
     int line = match.capturedRef(1).toInt() - 1;
     // captured(2) for pattern2 will yield null QString, toInt() thus 0, so no need for if-else
     // don't use an invalid column when the line is valid
     int column = qMax(0, match.captured(2).toInt() - 1);
 
     if (pathLength)
         *pathLength = match.capturedStart(0);
     return {line, column};
 }
 
 }
diff --git a/kdevplatform/util/texteditorhelpers.h b/kdevplatform/util/texteditorhelpers.h
index 50ae0a86c7..da66a68ef5 100644
--- a/kdevplatform/util/texteditorhelpers.h
+++ b/kdevplatform/util/texteditorhelpers.h
@@ -1,53 +1,53 @@
 /* This file is part of the KDE project
    Copyright 2015 Maciej Cencora
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_TEXTEDITORHELPERS_H
 #define KDEVPLATFORM_TEXTEDITORHELPERS_H
 
 #include <QRect>
 #include <KTextEditor/Range>
 
 #include "utilexport.h"
 
 namespace KTextEditor {
 class View;
 }
 
 namespace KDevelop {
 
 namespace KTextEditorHelpers {
 
 /// @return Item's bounding rect in global screen coordinates
-QRect KDEVPLATFORMUTIL_EXPORT getItemBoundingRect(const KTextEditor::View* view, const KTextEditor::Range& itemRange);
+QRect KDEVPLATFORMUTIL_EXPORT itemBoundingRect(const KTextEditor::View* view, const KTextEditor::Range& itemRange);
 
 /**
  * @brief Try parsing a string such as "path_to_file:line_num:column_num".
  *
  * Both line_num and column_num may be empty. Thus, other valid inputs are: "path_to_file", "path_to_file:line_num"
  * @param input Source string
  * @param pathLength Set to the length of the "path_to_file" string, you can use this to extract the raw path from the input string
  * @return Cursor representing line_num and column_num
  * */
 KTextEditor::Cursor KDEVPLATFORMUTIL_EXPORT extractCursor(const QString& input, int* pathLength = nullptr);
 
 }
 
 }
 
 #endif // KDEVPLATFORM_TEXTEDITORHELPERS_H
diff --git a/plugins/clang/codecompletion/context.cpp b/plugins/clang/codecompletion/context.cpp
index 9dc622152c..6118f719f9 100644
--- a/plugins/clang/codecompletion/context.cpp
+++ b/plugins/clang/codecompletion/context.cpp
@@ -1,1307 +1,1307 @@
 /*
  * This file is part of KDevelop
  * Copyright 2014 Milian Wolff <mail@milianw.de>
  * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "context.h"
 
 #include <QRegularExpression>
 #include <QStandardPaths>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/classmemberdeclaration.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/pointertype.h>
 #include <language/duchain/types/typealiastype.h>
 #include <language/duchain/types/typeutils.h>
 #include <language/codecompletion/codecompletionmodel.h>
 #include <language/codecompletion/normaldeclarationcompletionitem.h>
 #include <util/foregroundlock.h>
 #include <qtcompat_p.h>
 
 #include "../util/clangdebug.h"
 #include "../util/clangtypes.h"
 #include "../util/clangutils.h"
 #include "../duchain/clangdiagnosticevaluator.h"
 #include "../duchain/parsesession.h"
 #include "../duchain/duchainutils.h"
 #include "../duchain/navigationwidget.h"
 #include "../clangsettings/clangsettingsmanager.h"
 
 #include <functional>
 #include <memory>
 
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 using namespace KDevelop;
 
 namespace {
 /// Maximum return-type string length in completion items
 const int MAX_RETURN_TYPE_STRING_LENGTH = 20;
 
 /// Priority of code-completion results. NOTE: Keep in sync with Clang code base.
 enum CodeCompletionPriority {
   /// Priority for the next initialization in a constructor initializer list.
   CCP_NextInitializer = 7,
   /// Priority for an enumeration constant inside a switch whose condition is of the enumeration type.
   CCP_EnumInCase = 7,
 
   CCP_LocalDeclarationMatch = 8,
 
   CCP_DeclarationMatch = 12,
 
   CCP_LocalDeclarationSimiliar = 17,
   /// Priority for a send-to-super completion.
   CCP_SuperCompletion = 20,
 
   CCP_DeclarationSimiliar = 25,
   /// Priority for a declaration that is in the local scope.
   CCP_LocalDeclaration = 34,
   /// Priority for a member declaration found from the current method or member function.
   CCP_MemberDeclaration = 35,
   /// Priority for a language keyword (that isn't any of the other categories).
   CCP_Keyword = 40,
   /// Priority for a code pattern.
   CCP_CodePattern = 40,
   /// Priority for a non-type declaration.
   CCP_Declaration = 50,
   /// Priority for a type.
   CCP_Type = CCP_Declaration,
   /// Priority for a constant value (e.g., enumerator).
   CCP_Constant = 65,
   /// Priority for a preprocessor macro.
   CCP_Macro = 70,
   /// Priority for a nested-name-specifier.
   CCP_NestedNameSpecifier = 75,
   /// Priority for a result that isn't likely to be what the user wants, but is included for completeness.
   CCP_Unlikely = 80
 };
 
 /**
  * Common base class for Clang code completion items.
  */
 template<class Base>
 class CompletionItem : public Base
 {
 public:
     CompletionItem(const QString& display, const QString& prefix)
         : Base()
         , m_display(display)
         , m_prefix(prefix)
         , m_unimportant(false)
     {
     }
 
     ~CompletionItem() override = default;
 
     QVariant data(const QModelIndex& index, int role, const CodeCompletionModel* /*model*/) const override
     {
         if (role == Qt::DisplayRole) {
             if (index.column() == CodeCompletionModel::Prefix) {
                 return m_prefix;
             } else if (index.column() == CodeCompletionModel::Name) {
                 return m_display;
             }
         }
         return {};
     }
 
     void markAsUnimportant()
     {
         m_unimportant = true;
     }
 
 protected:
     QString m_display;
     QString m_prefix;
     bool m_unimportant;
 };
 
 class OverrideItem : public CompletionItem<CompletionTreeItem>
 {
 public:
     OverrideItem(const QString& nameAndParams, const QString& returnType)
         : CompletionItem<CompletionTreeItem>(
               nameAndParams,
               i18n("Override %1", returnType)
           )
         , m_returnType(returnType)
     {
     }
 
     QVariant data(const QModelIndex& index, int role, const CodeCompletionModel* model) const override
     {
         if (role == Qt::DecorationRole) {
             if (index.column() == KTextEditor::CodeCompletionModel::Icon) {
                 static const QIcon icon = QIcon::fromTheme(QStringLiteral("CTparents"));
                 return icon;
             }
         }
         return CompletionItem<CompletionTreeItem>::data(index, role, model);
     }
 
     void execute(KTextEditor::View* view, const KTextEditor::Range& word) override
     {
         view->document()->replaceText(word, m_returnType + QLatin1Char(' ') + m_display.replace(QRegularExpression(QStringLiteral("\\s*=\\s*0")), QString()) + QLatin1String(" override;"));
     }
 
 private:
     QString m_returnType;
 };
 
 /**
  * Specialized completion item class for items which are represented by a Declaration
  */
 class DeclarationItem : public CompletionItem<NormalDeclarationCompletionItem>
 {
 public:
     DeclarationItem(Declaration* dec, const QString& display, const QString& prefix, const QString& replacement)
         : CompletionItem<NormalDeclarationCompletionItem>(display, prefix)
         , m_replacement(replacement)
     {
         m_declaration = dec;
     }
 
     QVariant data(const QModelIndex& index, int role, const CodeCompletionModel* model) const override
     {
         if (role == CodeCompletionModel::MatchQuality && m_matchQuality) {
             return m_matchQuality;
         }
 
         auto ret = CompletionItem<NormalDeclarationCompletionItem>::data(index, role, model);
         if (ret.isValid()) {
             return ret;
         }
         return NormalDeclarationCompletionItem::data(index, role, model);
     }
 
     void execute(KTextEditor::View* view, const KTextEditor::Range& word) override
     {
         QString repl = m_replacement;
         DUChainReadLocker lock;
 
         if(!m_declaration){
             return;
         }
 
         if(m_declaration->isFunctionDeclaration()) {
             const auto functionType = m_declaration->type<FunctionType>();
 
             // protect against buggy code that created the m_declaration,
             // to mark it as a function but not assign a function type
             if (!functionType)
                 return;
 
             auto doc = view->document();
 
             // Function pointer?
             bool funcptr = false;
             const auto line = doc->line(word.start().line());
             auto pos = word.end().column() - 1;
             while ( pos > 0 && (line.at(pos).isLetterOrNumber() || line.at(pos) == QLatin1Char(':')) ) {
                 pos--;
                 if ( line.at(pos) == QLatin1Char('&') ) {
                     funcptr = true;
                     break;
                 }
             }
 
             auto restEmpty = doc->characterAt(word.end() + KTextEditor::Cursor{0, 1}) == QChar();
 
             bool didAddParentheses = false;
             if ( !funcptr && doc->characterAt(word.end()) != QLatin1Char('(') ) {
                 repl += QLatin1String("()");
                 didAddParentheses = true;
             }
             view->document()->replaceText(word, repl);
             if (functionType->indexedArgumentsSize() && didAddParentheses) {
                 view->setCursorPosition(word.start() + KTextEditor::Cursor(0, repl.size() - 1));
             }
             auto returnTypeIntegral = functionType->returnType().cast<IntegralType>();
             if ( restEmpty && !funcptr && returnTypeIntegral && returnTypeIntegral->dataType() == IntegralType::TypeVoid ) {
                 // function returns void and rest of line is empty -- nothing can be done with the result
                 if (functionType->indexedArgumentsSize() ) {
                     // we placed the cursor inside the ()
                     view->document()->insertText(view->cursorPosition() + KTextEditor::Cursor(0, 1), QStringLiteral(";"));
                 }
                 else {
                     // we placed the cursor after the ()
                     view->document()->insertText(view->cursorPosition(), QStringLiteral(";"));
                     view->setCursorPosition(view->cursorPosition() + KTextEditor::Cursor{0, 1});
                 }
             }
         } else {
             view->document()->replaceText(word, repl);
         }
     }
 
     bool createsExpandingWidget() const override
     {
         return true;
     }
 
     QWidget* createExpandingWidget(const CodeCompletionModel* /*model*/) const override
     {
         return new ClangNavigationWidget(m_declaration, AbstractNavigationWidget::EmbeddableWidget);
     }
 
     int matchQuality() const
     {
         return m_matchQuality;
     }
 
     ///Sets match quality from 0 to 10. 10 is the best fit.
     void setMatchQuality(int value)
     {
         m_matchQuality = value;
     }
 
     void setInheritanceDepth(int depth)
     {
         m_inheritanceDepth = depth;
     }
 
     int argumentHintDepth() const override
     {
         return m_depth;
     }
 
     void setArgumentHintDepth(int depth)
     {
         m_depth = depth;
     }
 
 protected:
     int m_matchQuality = 0;
     int m_depth = 0;
     QString m_replacement;
 };
 
 class ImplementsItem : public DeclarationItem
 {
 public:
     static QString replacement(const FuncImplementInfo& info)
     {
         QString replacement = info.templatePrefix;
         if (!info.isDestructor && !info.isConstructor) {
             replacement += info.returnType + QLatin1Char(' ');
         }
         replacement += info.prototype + QLatin1String("\n{\n}\n");
         return replacement;
     }
 
     explicit ImplementsItem(const FuncImplementInfo& item)
         : DeclarationItem(item.declaration.data(), item.prototype,
             i18n("Implement %1", item.isConstructor ? QStringLiteral("<constructor>") :
                                    item.isDestructor ? QStringLiteral("<destructor>") : item.returnType),
             replacement(item)
           )
     {
     }
 
     QVariant data(const QModelIndex& index, int role, const CodeCompletionModel* model) const override
     {
         if (index.column() == CodeCompletionModel::Arguments) {
             // our display string already contains the arguments
             return {};
         }
         return DeclarationItem::data(index, role, model);
     }
 
     void execute(KTextEditor::View* view, const KTextEditor::Range& word) override
     {
         view->document()->replaceText(word, m_replacement);
     }
 };
 
 class ArgumentHintItem : public DeclarationItem
 {
 public:
     struct CurrentArgumentRange
     {
         int start;
         int end;
     };
 
     ArgumentHintItem(Declaration* decl,  const QString& prefix, const QString& name, const QString& arguments, const CurrentArgumentRange& range)
         : DeclarationItem(decl, name, prefix, {})
         , m_range(range)
         , m_arguments(arguments)
     {}
 
     QVariant data(const QModelIndex& index, int role, const CodeCompletionModel* model) const override
     {
         if (role == CodeCompletionModel::CustomHighlight && index.column() == CodeCompletionModel::Arguments && argumentHintDepth()) {
             QTextCharFormat boldFormat;
             boldFormat.setFontWeight(QFont::Bold);
             const QList<QVariant> highlighting {
                 QVariant(m_range.start),
                 QVariant(m_range.end),
                 boldFormat,
             };
             return highlighting;
         }
 
         if (role == CodeCompletionModel::HighlightingMethod && index.column() == CodeCompletionModel::Arguments && argumentHintDepth()) {
             return QVariant(CodeCompletionModel::CustomHighlighting);
         }
 
         if (index.column() == CodeCompletionModel::Arguments) {
             return m_arguments;
         }
 
         return DeclarationItem::data(index, role, model);
     }
 
 private:
     CurrentArgumentRange m_range;
     QString m_arguments;
 };
 
 /**
  * A minimalistic completion item for macros and such
  */
 class SimpleItem : public CompletionItem<CompletionTreeItem>
 {
 public:
     SimpleItem(const QString& display, const QString& prefix, const QString& replacement, const QIcon& icon = QIcon())
         : CompletionItem<CompletionTreeItem>(display, prefix)
         , m_replacement(replacement)
         , m_icon(icon)
     {
     }
 
     void execute(KTextEditor::View* view, const KTextEditor::Range& word) override
     {
         view->document()->replaceText(word, m_replacement);
     }
 
     QVariant data(const QModelIndex& index, int role, const CodeCompletionModel* model) const override
     {
         if (role == Qt::DecorationRole && index.column() == KTextEditor::CodeCompletionModel::Icon) {
             return m_icon;
         }
         if (role == CodeCompletionModel::UnimportantItemRole) {
             return m_unimportant;
         }
         return CompletionItem<CompletionTreeItem>::data(index, role, model);
     }
 
 private:
     QString m_replacement;
     QIcon m_icon;
 };
 
 /**
  * Return true in case position @p position represents a cursor inside a comment
  */
 bool isInsideComment(CXTranslationUnit unit, CXFile file, const KTextEditor::Cursor& position)
 {
     if (!position.isValid()) {
         return false;
     }
 
     // TODO: This may get very slow for a large TU, investigate if we can improve this function
     auto begin = clang_getLocation(unit, file, 1, 1);
     auto end = clang_getLocation(unit, file, position.line() + 1, position.column() + 1);
     CXSourceRange range = clang_getRange(begin, end);
 
     // tokenize the whole range from the start until 'position'
     // if we detect a comment token at this position, return true
     const ClangTokens tokens(unit, range);
     for (CXToken token : tokens) {
         CXTokenKind tokenKind = clang_getTokenKind(token);
         if (tokenKind != CXToken_Comment) {
             continue;
         }
 
         auto range = ClangRange(clang_getTokenExtent(unit, token));
         if (range.toRange().contains(position)) {
             return true;
         }
     }
     return false;
 }
 
 QString& elideStringRight(QString& str, int length)
 {
     if (str.size() > length + 3) {
         return str.replace(length, str.size() - length, QStringLiteral("..."));
     }
     return str;
 }
 
 /**
  * @return Value suited for @ref CodeCompletionModel::MatchQuality in the range [0.0, 10.0] (the higher the better)
  *
  * See http://clang.llvm.org/doxygen/CodeCompleteConsumer_8h_source.html for list of priorities
  * They (currently) have a range from [-3, 80] (the lower, the better)
  */
 int codeCompletionPriorityToMatchQuality(unsigned int completionPriority)
 {
     return 10u - qBound(0u, completionPriority, 80u) / 8;
 }
 
 int adjustPriorityForType(const AbstractType::Ptr& type, int completionPriority)
 {
     const auto modifier = 4;
     if (type) {
         const auto whichType = type->whichType();
         if (whichType == AbstractType::TypePointer || whichType == AbstractType::TypeReference) {
             // Clang considers all pointers as similar, this is not what we want.
             completionPriority += modifier;
         } else if (whichType == AbstractType::TypeStructure) {
             // Clang considers all classes as similar too...
             completionPriority += modifier;
         } else if (whichType == AbstractType::TypeDelayed) {
             completionPriority += modifier;
         } else if (whichType == AbstractType::TypeAlias) {
             auto aliasedType = type.cast<TypeAliasType>();
             return adjustPriorityForType(aliasedType ? aliasedType->type() : AbstractType::Ptr(), completionPriority);
         } else if (whichType == AbstractType::TypeFunction) {
             auto functionType = type.cast<FunctionType>();
             return adjustPriorityForType(functionType ? functionType->returnType() : AbstractType::Ptr(), completionPriority);
         }
     } else {
         completionPriority += modifier;
     }
 
     return completionPriority;
 }
 
 /// Adjusts priority for the @p decl
 int adjustPriorityForDeclaration(Declaration* decl, unsigned int completionPriority)
 {
     if(completionPriority < CCP_LocalDeclarationSimiliar || completionPriority > CCP_SuperCompletion){
         return completionPriority;
     }
 
     return adjustPriorityForType(decl->abstractType(), completionPriority);
 }
 
 /**
  * @return Whether the declaration represented by identifier @p identifier qualifies as completion result
  *
  * For example, we don't want to offer SomeClass::SomeClass as completion item to the user
  * (otherwise we'd end up generating code such as 's.SomeClass();')
  */
 bool isValidCompletionIdentifier(const QualifiedIdentifier& identifier)
 {
     const int count = identifier.count();
     if (identifier.count() < 2) {
         return true;
     }
 
     const Identifier scope = identifier.at(count-2);
     const Identifier id = identifier.last();
     if (scope == id) {
         return false; // is constructor
     }
     const QString idString = id.toString();
     if (idString.startsWith(QLatin1Char('~')) && scope.toString() == idString.midRef(1)) {
         return false; // is destructor
     }
     return true;
 }
 
 /**
  * @return Whether the declaration represented by identifier @p identifier qualifies as "special" completion result
  *
  * "Special" completion results are items that are likely not regularly used.
  *
  * Examples:
  * - 'SomeClass::operator=(const SomeClass&)'
  */
 bool isValidSpecialCompletionIdentifier(const QualifiedIdentifier& identifier)
 {
     if (identifier.count() < 2) {
         return false;
     }
 
     const Identifier id = identifier.last();
     const QString idString = id.toString();
     if (idString.startsWith(QLatin1String("operator="))) {
         return true; // is assignment operator
     }
     return false;
 }
 
 Declaration* findDeclaration(const QualifiedIdentifier& qid, const DUContextPointer& ctx, const CursorInRevision& position, QSet<Declaration*>& handled)
 {
-    PersistentSymbolTable::Declarations decl = PersistentSymbolTable::self().getDeclarations(qid);
+    PersistentSymbolTable::Declarations decl = PersistentSymbolTable::self().declarations(qid);
 
     const auto top = ctx->topContext();
     const auto& importedContexts = top->importedParentContexts();
 
     for (auto it = decl.iterator(); it; ++it) {
         // if the context is not included, then this match is not correct for our consideration
         // this fixes issues where we used to include matches from files that did not have
         // anything to do with the current TU, e.g. the main from a different file or stuff like that
         // it also reduces the chance of us picking up a function of the same name from somewhere else
         // also, this makes sure the context has the correct language and we don't get confused by stuff
         // from other language plugins
         if (std::none_of(importedContexts.begin(), importedContexts.end(), [it] (const DUContext::Import& import) {
             return import.topContextIndex() == it->indexedTopContext().index();
         })) {
             continue;
         }
 
         auto declaration = it->declaration();
         if (!declaration) {
             // Mitigate problems such as: Cannot load a top-context from file "/home/kfunk/.cache/kdevduchain/kdevelop-{foo}/topcontexts/6085"
             //  - the required language-support for handling ID 55 is probably not loaded
             qCWarning(KDEV_CLANG) << "Detected an invalid declaration for" << qid;
             continue;
         }
 
         if (declaration->kind() == Declaration::Instance && !declaration->isFunctionDeclaration()) {
             break;
         }
         if (!handled.contains(declaration)) {
             handled.insert(declaration);
             return declaration;
         }
     }
 
     const auto foundDeclarations = ctx->findDeclarations(qid, position);
     for (auto dec : foundDeclarations) {
         if (!handled.contains(dec)) {
             handled.insert(dec);
             return dec;
         }
     }
 
     return nullptr;
 }
 
 /// If any parent of this context is a class, the closest class declaration is returned, nullptr otherwise
 Declaration* classDeclarationForContext(const DUContextPointer& context, const CursorInRevision& position)
 {
     auto parent = context;
     while (parent) {
         if (parent->type() == DUContext::Class) {
             break;
         }
 
         if (auto owner = parent->owner()) {
             // Work-around for out-of-line methods. They have Helper context instead of Class context
             if (owner->context() && owner->context()->type() == DUContext::Helper) {
                 auto qid = owner->qualifiedIdentifier();
                 qid.pop();
 
                 QSet<Declaration*> tmp;
                 auto decl = findDeclaration(qid, context, position, tmp);
 
                 if (decl && decl->internalContext() && decl->internalContext()->type() == DUContext::Class) {
                     parent = decl->internalContext();
                     break;
                 }
             }
         }
         parent = parent->parentContext();
     }
 
     return parent ? parent->owner() : nullptr;
 }
 
 class LookAheadItemMatcher
 {
 public:
     explicit LookAheadItemMatcher(const TopDUContextPointer& ctx)
         : m_topContext(ctx)
         , m_enabled(ClangSettingsManager::self()->codeCompletionSettings().lookAhead)
     {}
 
     /// Adds all local declarations for @p declaration into possible look-ahead items.
     void addDeclarations(Declaration* declaration)
     {
         if (!m_enabled) {
             return;
         }
 
         if (declaration->kind() != Declaration::Instance) {
             return;
         }
 
         auto type = typeForDeclaration(declaration);
         auto identifiedType = dynamic_cast<const IdentifiedType*>(type.data());
         if (!identifiedType) {
             return;
         }
 
         addDeclarationsForType(identifiedType, declaration);
     }
 
     /// Add type for matching. This type'll be used for filtering look-ahead items
     /// Only items with @p type will be returned through @sa matchedItems
     void addMatchedType(const IndexedType& type)
     {
         matchedTypes.insert(type);
     }
 
     /// @return look-ahead items that math given types. @sa addMatchedType
     QList<CompletionTreeItemPointer> matchedItems()
     {
         QList<CompletionTreeItemPointer> lookAheadItems;
         for (const auto& pair: qAsConst(possibleLookAheadDeclarations)) {
             auto decl = pair.first;
             if (matchedTypes.contains(decl->indexedType())) {
                 auto parent = pair.second;
                 const QString access = parent->abstractType()->whichType() == AbstractType::TypePointer
                                  ? QStringLiteral("->") : QStringLiteral(".");
                 const QString text = parent->identifier().toString() + access + decl->identifier().toString();
                 auto item = new DeclarationItem(decl, text, {}, text);
                 item->setMatchQuality(8);
                 lookAheadItems.append(CompletionTreeItemPointer(item));
             }
         }
 
         return lookAheadItems;
     }
 
 private:
     AbstractType::Ptr typeForDeclaration(const Declaration* decl)
     {
         return TypeUtils::targetType(decl->abstractType(), m_topContext.data());
     }
 
     void addDeclarationsForType(const IdentifiedType* identifiedType, Declaration* declaration)
     {
         if (auto typeDecl = identifiedType->declaration(m_topContext.data())) {
             if (dynamic_cast<ClassDeclaration*>(typeDecl->logicalDeclaration(m_topContext.data()))) {
                 if (!typeDecl->internalContext()) {
                     return;
                 }
 
                 const auto& localDeclarations = typeDecl->internalContext()->localDeclarations();
                 for (auto localDecl : localDeclarations) {
                     if(localDecl->identifier().isEmpty()){
                         continue;
                     }
 
                     if(auto classMember = dynamic_cast<ClassMemberDeclaration*>(localDecl)){
                         // TODO: Also add protected/private members if completion is inside this class context.
                         if(classMember->accessPolicy() != Declaration::Public){
                             continue;
                         }
                     }
 
                     if(!declaration->abstractType()){
                         continue;
                     }
 
                     if (declaration->abstractType()->whichType() == AbstractType::TypeIntegral) {
                         if (auto integralType = declaration->abstractType().cast<IntegralType>()) {
                             if (integralType->dataType() == IntegralType::TypeVoid) {
                                 continue;
                             }
                         }
                     }
 
                     possibleLookAheadDeclarations.insert({localDecl, declaration});
                 }
             }
         }
     }
 
     // Declaration and it's context
     typedef QPair<Declaration*, Declaration*> DeclarationContext;
 
     /// Types of declarations that look-ahead completion items can have
     QSet<IndexedType> matchedTypes;
 
     // List of declarations that can be added to the Look Ahead group
     // Second declaration represents context
     QSet<DeclarationContext> possibleLookAheadDeclarations;
 
     TopDUContextPointer m_topContext;
 
     bool m_enabled;
 };
 
 struct MemberAccessReplacer : public QObject
 {
     Q_OBJECT
 
 public:
     enum Type {
         None,
         DotToArrow,
         ArrowToDot
     };
 
 public Q_SLOTS:
     void replaceCurrentAccess(MemberAccessReplacer::Type type)
     {
         if (auto document = ICore::self()->documentController()->activeDocument()) {
             if (auto textDocument = document->textDocument()) {
                 auto activeView = document->activeTextView();
                 if (!activeView) {
                     return;
                 }
 
                 auto cursor = activeView->cursorPosition();
 
                 QString oldAccess, newAccess;
                 if (type == ArrowToDot) {
                     oldAccess = QStringLiteral("->");
                     newAccess = QStringLiteral(".");
                 } else {
                     oldAccess = QStringLiteral(".");
                     newAccess = QStringLiteral("->");
                 }
 
                 auto oldRange = KTextEditor::Range(cursor - KTextEditor::Cursor(0, oldAccess.length()), cursor);
 
                 // This code needed for testReplaceMemberAccess test
                 // Maybe we should do a similar thing for '->' to '.' direction, but this is not so important
                 while (textDocument->text(oldRange) == QLatin1String(" ") && oldRange.start().column() >= 0) {
                     oldRange = KTextEditor::Range({oldRange.start().line(), oldRange.start().column() - 1},
                                                   {oldRange.end().line(), oldRange.end().column() - 1});
                 }
 
                 if (oldRange.start().column() >= 0 && textDocument->text(oldRange) == oldAccess) {
                     textDocument->replaceText(oldRange, newAccess);
                 }
             }
         }
     }
 };
 static MemberAccessReplacer s_memberAccessReplacer;
 
 }
 
 Q_DECLARE_METATYPE(MemberAccessReplacer::Type)
 
 ClangCodeCompletionContext::ClangCodeCompletionContext(const DUContextPointer& context,
                                                        const ParseSessionData::Ptr& sessionData,
                                                        const QUrl& url,
                                                        const KTextEditor::Cursor& position,
                                                        const QString& text,
                                                        const QString& followingText
                                                       )
     : CodeCompletionContext(context, text + followingText, CursorInRevision::castFromSimpleCursor(position), 0)
     , m_results(nullptr, clang_disposeCodeCompleteResults)
     , m_parseSessionData(sessionData)
 {
     qRegisterMetaType<MemberAccessReplacer::Type>();
     const QByteArray file = url.toLocalFile().toUtf8();
     ParseSession session(m_parseSessionData);
 
     QVector<UnsavedFile> otherUnsavedFiles;
     {
         ForegroundLock lock;
         otherUnsavedFiles = ClangUtils::unsavedFiles();
     }
     QVector<CXUnsavedFile> allUnsaved;
 
     {
         const unsigned int completeOptions = clang_defaultCodeCompleteOptions();
 
         CXUnsavedFile unsaved;
         unsaved.Filename = file.constData();
         const QByteArray content = m_text.toUtf8();
         unsaved.Contents = content.constData();
         unsaved.Length = content.size();
 
         allUnsaved.reserve(otherUnsavedFiles.size() + 1);
         for (const auto& f : qAsConst(otherUnsavedFiles)) {
             allUnsaved.append(f.toClangApi());
         }
         allUnsaved.append(unsaved);
 
         m_results.reset(clang_codeCompleteAt(session.unit(), file.constData(),
                         position.line() + 1, position.column() + 1,
                         allUnsaved.data(), allUnsaved.size(),
                         completeOptions));
 
         if (!m_results) {
             qCWarning(KDEV_CLANG) << "Something went wrong during 'clang_codeCompleteAt' for file" << file;
             return;
         }
 
         auto numDiagnostics = clang_codeCompleteGetNumDiagnostics(m_results.get());
         for (uint i = 0; i < numDiagnostics; i++) {
             auto diagnostic = clang_codeCompleteGetDiagnostic(m_results.get(), i);
             auto diagnosticType = ClangDiagnosticEvaluator::diagnosticType(diagnostic);
             clang_disposeDiagnostic(diagnostic);
             if (diagnosticType == ClangDiagnosticEvaluator::ReplaceWithArrowProblem || diagnosticType == ClangDiagnosticEvaluator::ReplaceWithDotProblem) {
                 MemberAccessReplacer::Type replacementType;
                 if (diagnosticType == ClangDiagnosticEvaluator::ReplaceWithDotProblem) {
                     replacementType = MemberAccessReplacer::ArrowToDot;
                 } else {
                     replacementType = MemberAccessReplacer::DotToArrow;
                 }
 
                 QMetaObject::invokeMethod(&s_memberAccessReplacer, "replaceCurrentAccess", Qt::QueuedConnection,
                                           Q_ARG(MemberAccessReplacer::Type, replacementType));
 
                 m_valid = false;
                 return;
             }
         }
 
         auto addMacros = ClangSettingsManager::self()->codeCompletionSettings().macros;
         if (!addMacros) {
             m_filters |= NoMacros;
         }
     }
 
     if (!m_results->NumResults) {
         const auto trimmedText = text.trimmed();
         if (trimmedText.endsWith(QLatin1Char('.'))) {
             // TODO: This shouldn't be needed if Clang provided diagnostic.
             // But it doesn't always do it, so let's try to manually determine whether '.' is used instead of '->'
             m_text = trimmedText.leftRef(trimmedText.size() - 1) + QStringLiteral("->");
 
             CXUnsavedFile unsaved;
             unsaved.Filename = file.constData();
             const QByteArray content = m_text.toUtf8();
             unsaved.Contents = content.constData();
             unsaved.Length = content.size();
             allUnsaved[allUnsaved.size() - 1] = unsaved;
 
             m_results.reset(clang_codeCompleteAt(session.unit(), file.constData(),
                                                  position.line() + 1, position.column() + 1 + 1,
                                                  allUnsaved.data(), allUnsaved.size(),
                                                  clang_defaultCodeCompleteOptions()));
 
             if (m_results && m_results->NumResults) {
                 QMetaObject::invokeMethod(&s_memberAccessReplacer, "replaceCurrentAccess", Qt::QueuedConnection,
                                           Q_ARG(MemberAccessReplacer::Type, MemberAccessReplacer::DotToArrow));
             }
 
             m_valid = false;
             return;
         }
     }
 
     // check 'isValidPosition' after parsing the new content
     auto clangFile = session.file(file);
     if (!isValidPosition(session.unit(), clangFile)) {
         m_valid = false;
         return;
     }
 
     m_completionHelper.computeCompletions(session, clangFile, position);
 }
 
 ClangCodeCompletionContext::~ClangCodeCompletionContext()
 {
 }
 
 bool ClangCodeCompletionContext::isValidPosition(CXTranslationUnit unit, CXFile file) const
 {
     if (isInsideComment(unit, file, m_position.castToSimpleCursor())) {
         clangDebug() << "Invalid completion context: Inside comment";
         return false;
     }
     return true;
 }
 
 QList<CompletionTreeItemPointer> ClangCodeCompletionContext::completionItems(bool& abort, bool /*fullCompletion*/)
 {
     if (!m_valid || !m_duContext || !m_results) {
         return {};
     }
 
     const auto ctx = DUContextPointer(m_duContext->findContextAt(m_position));
 
     /// Normal completion items, such as 'void Foo::foo()'
     QList<CompletionTreeItemPointer> items;
     /// Stuff like 'Foo& Foo::operator=(const Foo&)', etc. Not regularly used by our users.
     QList<CompletionTreeItemPointer> specialItems;
     /// Macros from the current context
     QList<CompletionTreeItemPointer> macros;
     /// Builtins reported by Clang
     QList<CompletionTreeItemPointer> builtin;
 
     // two sets of handled declarations to prevent duplicates and make sure we show
     // all available overloads
     QSet<Declaration*> handled;
     // this is only used for the CXCursor_OverloadCandidate completion items
     QSet<Declaration*> overloadsHandled;
 
     LookAheadItemMatcher lookAheadMatcher(TopDUContextPointer(ctx->topContext()));
 
     // If ctx is/inside the Class context, this represents that context.
     const auto currentClassContext = classDeclarationForContext(ctx, m_position);
 
     clangDebug() << "Clang found" << m_results->NumResults << "completion results";
 
     for (uint i = 0; i < m_results->NumResults; ++i) {
         if (abort) {
             return {};
         }
 
         auto result = m_results->Results[i];
         #if CINDEX_VERSION_MINOR >= 30
         const bool isOverloadCandidate = result.CursorKind == CXCursor_OverloadCandidate;
         #else
         const bool isOverloadCandidate = false;
         #endif
 
         const auto availability = clang_getCompletionAvailability(result.CompletionString);
         if (availability == CXAvailability_NotAvailable) {
             continue;
         }
 
         const bool isMacroDefinition = result.CursorKind == CXCursor_MacroDefinition;
         if (isMacroDefinition && m_filters & NoMacros) {
             continue;
         }
 
         const bool isBuiltin = (result.CursorKind == CXCursor_NotImplemented);
         if (isBuiltin && m_filters & NoBuiltins) {
             continue;
         }
 
         const bool isDeclaration = !isMacroDefinition && !isBuiltin;
         if (isDeclaration && m_filters & NoDeclarations) {
             continue;
         }
 
         if (availability == CXAvailability_NotAccessible && (!isDeclaration || !currentClassContext)) {
             continue;
         }
 
         // the string that would be needed to type, usually the identifier of something. Also we use it as name for code completion declaration items.
         QString typed;
         // the return type of a function e.g.
         QString resultType;
         // the replacement text when an item gets executed
         QString replacement;
 
         QString arguments;
 
         ArgumentHintItem::CurrentArgumentRange argumentRange;
         //BEGIN function signature parsing
         // nesting depth of parentheses
         int parenDepth = 0;
         enum FunctionSignatureState {
             // not yet inside the function signature
             Before,
             // any token is part of the function signature now
             Inside,
             // finished parsing the function signature
             After
         };
         // current state
         FunctionSignatureState signatureState = Before;
         //END function signature parsing
 
         std::function<void (CXCompletionString)> processChunks = [&] (CXCompletionString completionString) {
             const uint chunks = clang_getNumCompletionChunks(completionString);
             for (uint j = 0; j < chunks; ++j) {
                 const auto kind = clang_getCompletionChunkKind(completionString, j);
                 if (kind == CXCompletionChunk_Optional) {
                     completionString = clang_getCompletionChunkCompletionString(completionString, j);
                     if (completionString) {
                         processChunks(completionString);
                     }
                     continue;
                 }
 
                 // We don't need function signature for declaration items, we can get it directly from the declaration. Also adding the function signature to the "display" would break the "Detailed completion" option.
                 if (isDeclaration && !typed.isEmpty()) {
                     // TODO: When parent context for CXCursor_OverloadCandidate is fixed remove this check
                     if (!isOverloadCandidate) {
                         break;
                     }
                 }
 
                 const QString string = ClangString(clang_getCompletionChunkText(completionString, j)).toString();
 
                 switch (kind) {
                 case CXCompletionChunk_TypedText:
                     typed = string;
                     replacement += string;
                     break;
                 case CXCompletionChunk_ResultType:
                     resultType = string;
                     continue;
                 case CXCompletionChunk_Placeholder:
                     if (signatureState == Inside) {
                         arguments += string;
                     }
                     continue;
                 case CXCompletionChunk_LeftParen:
                     if (signatureState == Before && !parenDepth) {
                         signatureState = Inside;
                     }
                     parenDepth++;
                     break;
                 case CXCompletionChunk_RightParen:
                     --parenDepth;
                     if (signatureState == Inside && !parenDepth) {
                         arguments += QLatin1Char(')');
                         signatureState = After;
                     }
                     break;
                 case CXCompletionChunk_Text:
                     if (isOverloadCandidate) {
                         typed += string;
                     }
                     else if (result.CursorKind == CXCursor_EnumConstantDecl) {
                         replacement += string;
                     }
                     else if (result.CursorKind == CXCursor_EnumConstantDecl) {
                         replacement += string;
                     }
                     break;
                 case CXCompletionChunk_CurrentParameter:
                     argumentRange.start = arguments.size();
                     argumentRange.end = string.size();
                     break;
                 default:
                     break;
                 }
                 if (signatureState == Inside) {
                     arguments += string;
                 }
             }
         };
 
         processChunks(result.CompletionString);
 
         // TODO: No closing paren if default parameters present
         if (isOverloadCandidate && !arguments.endsWith(QLatin1Char(')'))) {
             arguments += QLatin1Char(')');
         }
         // ellide text to the right for overly long result types (templates especially)
         elideStringRight(resultType, MAX_RETURN_TYPE_STRING_LENGTH);
 
         static const auto noIcon = QIcon(QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                                 QStringLiteral("kdevelop/pics/namespace.png")));
 
         if (isDeclaration) {
             const Identifier id(typed);
             QualifiedIdentifier qid;
             ClangString parent(clang_getCompletionParent(result.CompletionString, nullptr));
             if (parent.c_str() != nullptr) {
                 qid = QualifiedIdentifier(parent.toString());
             }
             qid.push(id);
 
             if (!isValidCompletionIdentifier(qid)) {
                 continue;
             }
 
             if (isOverloadCandidate && resultType.isEmpty() && parent.isEmpty()) {
                 // workaround: find constructor calls for non-namespaced classes
                 // TODO: return the namespaced class as parent in libclang
                 qid.push(id);
             }
 
             auto found = findDeclaration(qid, ctx, m_position, isOverloadCandidate ? overloadsHandled : handled);
 
             CompletionTreeItemPointer item;
             if (found) {
                 // TODO: Bug in Clang: protected members from base classes not accessible in derived classes.
                 if (availability == CXAvailability_NotAccessible) {
                     if (auto cl = dynamic_cast<ClassMemberDeclaration*>(found)) {
                         if (cl->accessPolicy() != Declaration::Protected) {
                             continue;
                         }
 
                         auto declarationClassContext = classDeclarationForContext(DUContextPointer(found->context()), m_position);
 
                         uint steps = 10;
-                        auto inheriters = DUChainUtils::getInheriters(declarationClassContext, steps);
+                        auto inheriters = DUChainUtils::inheriters(declarationClassContext, steps);
                         if(!inheriters.contains(currentClassContext)){
                             continue;
                         }
                     } else {
                         continue;
                     }
                 }
 
                 DeclarationItem* declarationItem = nullptr;
                 if (isOverloadCandidate) {
                     declarationItem = new ArgumentHintItem(found, resultType, typed, arguments, argumentRange);
                     declarationItem->setArgumentHintDepth(1);
                 } else {
                     declarationItem = new DeclarationItem(found, typed, resultType, replacement);
                 }
 
                 const unsigned int completionPriority = adjustPriorityForDeclaration(found, clang_getCompletionPriority(result.CompletionString));
                 const bool bestMatch = completionPriority <= CCP_SuperCompletion;
 
                 //don't set best match property for internal identifiers, also prefer declarations from current file
                 const auto isInternal = found->indexedIdentifier().identifier().toString().startsWith(QLatin1String("__"));
                 if (bestMatch && !isInternal ) {
                     const int matchQuality = codeCompletionPriorityToMatchQuality(completionPriority);
                     declarationItem->setMatchQuality(matchQuality);
 
                     // TODO: LibClang missing API to determine expected code completion type.
                     lookAheadMatcher.addMatchedType(found->indexedType());
                 } else {
                     declarationItem->setInheritanceDepth(completionPriority);
 
                     lookAheadMatcher.addDeclarations(found);
                 }
                 if ( isInternal ) {
                     declarationItem->markAsUnimportant();
                 }
 
                 item = declarationItem;
             } else {
                 if (isOverloadCandidate) {
                     // TODO: No parent context for CXCursor_OverloadCandidate items, hence qid is broken -> no declaration found
                     auto ahi = new ArgumentHintItem({}, resultType, typed, arguments, argumentRange);
                     ahi->setArgumentHintDepth(1);
                     item = ahi;
                 } else {
                     // still, let's trust that Clang found something useful and put it into the completion result list
                     clangDebug() << "Could not find declaration for" << qid;
                     auto instance = new SimpleItem(typed + arguments, resultType, replacement, noIcon);
                     instance->markAsUnimportant();
                     item = CompletionTreeItemPointer(instance);
                 }
             }
 
             if (isValidSpecialCompletionIdentifier(qid)) {
                 // If it's a special completion identifier e.g. "operator=(const&)" and we don't have a declaration for it, don't add it into completion list, as this item is completely useless and pollutes the test case.
                 // This happens e.g. for "class A{}; a.|".  At | we have "operator=(const A&)" as a special completion identifier without a declaration.
                 if(item->declaration()){
                     specialItems.append(item);
                 }
             } else {
                 items.append(item);
             }
             continue;
         }
 
         if (result.CursorKind == CXCursor_MacroDefinition) {
             // TODO: grouping of macros and built-in stuff
             const auto text = QString(typed + arguments);
             auto instance = new SimpleItem(text, resultType, replacement, noIcon);
             auto item = CompletionTreeItemPointer(instance);
             if ( text.startsWith(QLatin1Char('_')) ) {
                 instance->markAsUnimportant();
             }
             macros.append(item);
         } else if (result.CursorKind == CXCursor_NotImplemented) {
             auto instance = new SimpleItem(typed, resultType, replacement, noIcon);
             auto item = CompletionTreeItemPointer(instance);
             builtin.append(item);
         }
     }
 
     if (abort) {
         return {};
     }
 
     addImplementationHelperItems();
     addOverwritableItems();
 
     eventuallyAddGroup(i18n("Special"), 700, specialItems);
     eventuallyAddGroup(i18n("Look-ahead Matches"), 800, lookAheadMatcher.matchedItems());
     eventuallyAddGroup(i18n("Builtin"), 900, builtin);
     eventuallyAddGroup(i18n("Macros"), 1000, macros);
     return items;
 }
 
 void ClangCodeCompletionContext::eventuallyAddGroup(const QString& name, int priority,
                                                     const QList<CompletionTreeItemPointer>& items)
 {
     if (items.isEmpty()) {
         return;
     }
 
     auto* node = new CompletionCustomGroupNode(name, priority);
     node->appendChildren(items);
     m_ungrouped << CompletionTreeElementPointer(node);
 }
 
 void ClangCodeCompletionContext::addOverwritableItems()
 {
     auto overrideList = m_completionHelper.overrides();
     if (overrideList.isEmpty()) {
         return;
     }
 
     QList<CompletionTreeItemPointer> overrides;
     QList<CompletionTreeItemPointer> overridesAbstract;
     for (const auto& info : overrideList) {
         QStringList params;
         params.reserve(info.params.size());
         for (const auto& param : info.params) {
             params << param.type + QLatin1Char(' ') + param.id;
         }
         QString nameAndParams = info.name + QLatin1Char('(') + params.join(QStringLiteral(", ")) + QLatin1Char(')');
         if(info.isConst)
             nameAndParams = nameAndParams + QLatin1String(" const");
         if(info.isPureVirtual)
             nameAndParams = nameAndParams + QLatin1String(" = 0");
 
         auto item = CompletionTreeItemPointer(new OverrideItem(nameAndParams, info.returnType));
         if (info.isPureVirtual)
             overridesAbstract << item;
         else
             overrides << item;
     }
     eventuallyAddGroup(i18n("Abstract Override"), 0, overridesAbstract);
     eventuallyAddGroup(i18n("Virtual Override"), 0, overrides);
 }
 
 void ClangCodeCompletionContext::addImplementationHelperItems()
 {
     const auto implementsList = m_completionHelper.implements();
     if (implementsList.isEmpty()) {
         return;
     }
 
     QList<CompletionTreeItemPointer> implements;
     implements.reserve(implementsList.size());
     for (const auto& info : implementsList) {
         implements << CompletionTreeItemPointer(new ImplementsItem(info));
     }
     eventuallyAddGroup(i18n("Implement Function"), 0, implements);
 }
 
 
 QList<CompletionTreeElementPointer> ClangCodeCompletionContext::ungroupedElements()
 {
     return m_ungrouped;
 }
 
 ClangCodeCompletionContext::ContextFilters ClangCodeCompletionContext::filters() const
 {
     return m_filters;
 }
 
 void ClangCodeCompletionContext::setFilters(const ClangCodeCompletionContext::ContextFilters& filters)
 {
     m_filters = filters;
 }
 
 #include "context.moc"
diff --git a/plugins/clang/codegen/adaptsignatureaction.cpp b/plugins/clang/codegen/adaptsignatureaction.cpp
index b0ef54acba..cd9e0a2b7c 100644
--- a/plugins/clang/codegen/adaptsignatureaction.cpp
+++ b/plugins/clang/codegen/adaptsignatureaction.cpp
@@ -1,131 +1,131 @@
 /*
    Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2014 Kevin Funk <kfunk@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "adaptsignatureaction.h"
 #include "codegenhelper.h"
 
 #include "../duchain/duchainutils.h"
 #include "../util/clangdebug.h"
 
 #include <language/assistant/renameaction.h>
 #include <language/codegen/documentchangeset.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/functiondefinition.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 using namespace KDevelop;
 
 AdaptSignatureAction::AdaptSignatureAction(const DeclarationId& definitionId,
                                            const ReferencedTopDUContext& definitionContext,
                                            const Signature& oldSignature,
                                            const Signature& newSignature,
                                            bool editingDefinition,
                                            const QList<RenameAction*>& renameActions)
     : m_otherSideId(definitionId)
     , m_otherSideTopContext(definitionContext)
     , m_oldSignature(oldSignature)
     , m_newSignature(newSignature)
     , m_editingDefinition(editingDefinition)
     , m_renameActions(renameActions)
 {
 }
 
 AdaptSignatureAction::~AdaptSignatureAction()
 {
     qDeleteAll(m_renameActions);
 }
 
 QString AdaptSignatureAction::description() const
 {
     return m_editingDefinition ? i18n("Update declaration signature") : i18n("Update definition signature");
 }
 
 QString AdaptSignatureAction::toolTip() const
 {
     DUChainReadLocker lock;
-    auto declaration = m_otherSideId.getDeclaration(m_otherSideTopContext.data());
+    auto declaration = m_otherSideId.declaration(m_otherSideTopContext.data());
     if (!declaration) {
         return {};
     }
     KLocalizedString msg = m_editingDefinition
                          ? ki18n("Update declaration signature\nfrom: %1\nto: %2")
                          : ki18n("Update definition signature\nfrom: %1\nto: %2");
     msg = msg.subs(CodegenHelper::makeSignatureString(declaration, m_oldSignature, m_editingDefinition));
     msg = msg.subs(CodegenHelper::makeSignatureString(declaration, m_newSignature, !m_editingDefinition));
     return msg.toString();
 }
 
 void AdaptSignatureAction::execute()
 {
     ENSURE_CHAIN_NOT_LOCKED
     DUChainReadLocker lock;
     IndexedString url = m_otherSideTopContext->url();
     lock.unlock();
     m_otherSideTopContext = DUChain::self()->waitForUpdate(url, TopDUContext::AllDeclarationsContextsAndUses);
     if (!m_otherSideTopContext) {
         clangDebug() << "failed to update" << url.str();
         return;
     }
 
     lock.lock();
 
-    Declaration* otherSide = m_otherSideId.getDeclaration(m_otherSideTopContext.data());
+    Declaration* otherSide = m_otherSideId.declaration(m_otherSideTopContext.data());
     if (!otherSide) {
         clangDebug() << "could not find definition";
         return;
     }
-    DUContext* functionContext = DUChainUtils::getFunctionContext(otherSide);
+    DUContext* functionContext = DUChainUtils::functionContext(otherSide);
     if (!functionContext) {
         clangDebug() << "no function context";
         return;
     }
     if (!functionContext || functionContext->type() != DUContext::Function) {
         clangDebug() << "no correct function context";
         return;
     }
 
     DocumentChangeSet changes;
     KTextEditor::Range parameterRange = ClangIntegration::DUChainUtils::functionSignatureRange(otherSide);
     QString newText = CodegenHelper::makeSignatureString(otherSide, m_newSignature, !m_editingDefinition);
     if (!m_editingDefinition) {
         // append a newline after the method signature in case the method definition follows
         newText += QLatin1Char('\n');
     }
 
     DocumentChange changeParameters(functionContext->url(), parameterRange, QString(), newText);
     lock.unlock();
     changeParameters.m_ignoreOldText = true;
     changes.addChange(changeParameters);
     changes.setReplacementPolicy(DocumentChangeSet::WarnOnFailedChange);
     DocumentChangeSet::ChangeResult result = changes.applyAllChanges();
     if (!result) {
         KMessageBox::error(nullptr, i18n("Failed to apply changes: %1", result.m_failureReason));
     }
     emit executed(this);
 
     foreach(RenameAction * renAct, m_renameActions) {
         renAct->execute();
     }
 }
 
 #include "moc_adaptsignatureaction.cpp"
diff --git a/plugins/clang/codegen/adaptsignatureassistant.cpp b/plugins/clang/codegen/adaptsignatureassistant.cpp
index 3d363a8950..7c39a88a9b 100644
--- a/plugins/clang/codegen/adaptsignatureassistant.cpp
+++ b/plugins/clang/codegen/adaptsignatureassistant.cpp
@@ -1,323 +1,323 @@
 /*
    Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
    Copyright 2014 Kevin Funk <kfunk@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "adaptsignatureassistant.h"
 
 #include <interfaces/icore.h>
 #include <language/assistant/renameaction.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <language/duchain/types/functiontype.h>
 
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include "../util/clangdebug.h"
 
 using namespace KDevelop;
 
 namespace {
 Declaration *getDeclarationAtCursor(const KTextEditor::Cursor &cursor, const QUrl &documentUrl)
 {
     ENSURE_CHAIN_READ_LOCKED
     ReferencedTopDUContext top(DUChainUtils::standardContextForUrl(documentUrl));
     if (!top) {
         clangDebug() << "no context found for document" << documentUrl;
         return nullptr;
     }
     const auto *context = top->findContextAt(top->transformToLocalRevision(cursor), true);
     return context->type() == DUContext::Function ? context->owner() : nullptr;
 }
 
 bool isConstructor(const Declaration *functionDecl)
 {
     auto classFun = dynamic_cast<const ClassFunctionDeclaration*>(DUChainUtils::declarationForDefinition(const_cast<Declaration*>(functionDecl)));
     return classFun && classFun->isConstructor();
 }
 
 Signature getDeclarationSignature(const Declaration *functionDecl, const DUContext *functionCtxt, bool includeDefaults)
 {
     ENSURE_CHAIN_READ_LOCKED
     int pos = 0;
     Signature signature;
     const AbstractFunctionDeclaration* abstractFunDecl = dynamic_cast<const AbstractFunctionDeclaration*>(functionDecl);
     const auto localDeclarations = functionCtxt->localDeclarations();
     const int localDeclarationsCount = localDeclarations.size();
     signature.defaultParams.reserve(localDeclarationsCount);
     signature.parameters.reserve(localDeclarationsCount);
     for (Declaration * parameter : localDeclarations) {
         signature.defaultParams << (includeDefaults ? abstractFunDecl->defaultParameterForArgument(pos).str() : QString());
         signature.parameters << qMakePair(parameter->indexedType(), parameter->identifier().identifier().str());
         ++pos;
     }
     signature.isConst = functionDecl->abstractType() && functionDecl->abstractType()->modifiers() & AbstractType::ConstModifier;
 
     if (!isConstructor(functionDecl)) {
         if (auto funType = functionDecl->type<FunctionType>()) {
             signature.returnType = IndexedType(funType->returnType());
         }
     }
     return signature;
 }
 }
 
 AdaptSignatureAssistant::AdaptSignatureAssistant(ILanguageSupport* supportedLanguage)
     : StaticAssistant(supportedLanguage)
 {
 }
 
 QString AdaptSignatureAssistant::title() const
 {
     return i18n("Adapt Signature");
 }
 
 void AdaptSignatureAssistant::reset()
 {
     doHide();
     clearActions();
 
     m_editingDefinition = {};
     m_declarationName = {};
     m_otherSideId = DeclarationId();
     m_otherSideTopContext = {};
     m_otherSideContext = {};
     m_oldSignature = {};
     m_document = nullptr;
     m_view.clear();
 }
 
 void AdaptSignatureAssistant::textChanged(KTextEditor::Document* doc, const KTextEditor::Range& invocationRange, const QString& removedText)
 {
     reset();
 
     m_document = doc;
     m_lastEditPosition = invocationRange.end();
 
     KTextEditor::Range sigAssistRange = invocationRange;
     if (!removedText.isEmpty()) {
         sigAssistRange.setRange(sigAssistRange.start(), sigAssistRange.start());
     }
 
     DUChainReadLocker lock(DUChain::lock(), 300);
     if (!lock.locked()) {
         clangDebug() << "failed to lock duchain in time";
         return;
     }
     KTextEditor::Range simpleInvocationRange = KTextEditor::Range(sigAssistRange);
     Declaration* funDecl = getDeclarationAtCursor(simpleInvocationRange.start(), m_document->url());
     if (!funDecl || !funDecl->type<FunctionType>()) {
         clangDebug() << "No function at cursor";
         return;
     }
     /*
        TODO: Port?
        if(QtFunctionDeclaration* classFun = dynamic_cast<QtFunctionDeclaration*>(funDecl)) {
        if (classFun->isSignal()) {
         // do not offer to change signature of a signal, as the implementation will be generated by moc
         return;
        }
        }
      */
 
     Declaration* otherSide = nullptr;
     FunctionDefinition* definition = dynamic_cast<FunctionDefinition*>(funDecl);
     if (definition) {
         m_editingDefinition = true;
         otherSide = definition->declaration();
     } else if ((definition = FunctionDefinition::definition(funDecl))) {
         m_editingDefinition = false;
         otherSide = definition;
     }
     if (!otherSide) {
         clangDebug() << "no other side for signature found";
         return;
     }
-    m_otherSideContext = DUContextPointer(DUChainUtils::getFunctionContext(otherSide));
+    m_otherSideContext = DUContextPointer(DUChainUtils::functionContext(otherSide));
     if (!m_otherSideContext) {
         clangDebug() << "no context for other side found";
         return;
     }
     m_declarationName = funDecl->identifier();
     m_otherSideId = otherSide->id();
     m_otherSideTopContext = ReferencedTopDUContext(otherSide->topContext());
     m_oldSignature = getDeclarationSignature(otherSide, m_otherSideContext.data(), true);
 
     //Schedule an update, to make sure the ranges match
     DUChain::self()->updateContextForUrl(m_otherSideTopContext->url(), TopDUContext::AllDeclarationsAndContexts);
 }
 
 bool AdaptSignatureAssistant::isUseful() const
 {
     return !m_declarationName.isEmpty() && m_otherSideId.isValid() && !actions().isEmpty();
 }
 
 bool AdaptSignatureAssistant::getSignatureChanges(const Signature& newSignature, QList<int>& oldPositions) const
 {
     bool changed = false;
     oldPositions.reserve(oldPositions.size() + newSignature.parameters.size());
     for (int i = 0; i < newSignature.parameters.size(); ++i) {
         oldPositions.append(-1);
     }
 
     for (int curNewParam = newSignature.parameters.size() - 1; curNewParam >= 0; --curNewParam) {
         int foundAt = -1;
 
         for (int curOldParam = m_oldSignature.parameters.size() - 1; curOldParam >= 0; --curOldParam) {
             if (newSignature.parameters[curNewParam].first != m_oldSignature.parameters[curOldParam].first) {
                 continue;  //Different type == different parameters
             }
             if (newSignature.parameters[curNewParam].second == m_oldSignature.parameters[curOldParam].second || curOldParam == curNewParam) {
                 //given the same type and either the same position or the same name, it's (probably) the same argument
                 foundAt = curOldParam;
 
                 if (newSignature.parameters[curNewParam].second != m_oldSignature.parameters[curOldParam].second || curOldParam != curNewParam) {
                     changed = true;  //Either the name changed at this position, or position of this name has changed
                 }
                 if (newSignature.parameters[curNewParam].second == m_oldSignature.parameters[curOldParam].second) {
                     break;  //Found an argument with the same name and type, no need to look further
                 }
                 //else: position/type match, but name match will trump, allowing: (int i=0, int j=1) => (int j=1, int i=0)
             }
         }
 
         if (foundAt < 0) {
             changed = true;
         }
         oldPositions[curNewParam] = foundAt;
     }
 
     if (newSignature.parameters.size() != m_oldSignature.parameters.size()) {
         changed = true;
     }
     if (newSignature.isConst != m_oldSignature.isConst) {
         changed = true;
     }
     if (newSignature.returnType != m_oldSignature.returnType) {
         changed = true;
     }
     return changed;
 }
 
 void AdaptSignatureAssistant::setDefaultParams(Signature& newSignature, const QList<int>& oldPositions) const
 {
     bool hadDefaultParam = false;
     for (int i = 0; i < newSignature.defaultParams.size(); ++i) {
         const auto oldPos = oldPositions[i];
         if (oldPos == -1) {
             // default-initialize new argument if we encountered a previous default param
             if (hadDefaultParam) {
                 newSignature.defaultParams[i] = QStringLiteral("{} /* TODO */");
             }
         } else {
             newSignature.defaultParams[i] = m_oldSignature.defaultParams[oldPos];
             hadDefaultParam = hadDefaultParam || !newSignature.defaultParams[i].isEmpty();
         }
     }
 }
 
 QList<RenameAction*> AdaptSignatureAssistant::getRenameActions(const Signature &newSignature, const QList<int> &oldPositions) const
 {
     ENSURE_CHAIN_READ_LOCKED
     QList<RenameAction*> renameActions;
     if (!m_otherSideContext) {
         return renameActions;
     }
     for (int i = newSignature.parameters.size() - 1; i >= 0; --i) {
         if (oldPositions[i] == -1) {
             continue;  //new parameter
         }
         Declaration *renamedDecl = m_otherSideContext->localDeclarations()[oldPositions[i]];
         if (newSignature.parameters[i].second != m_oldSignature.parameters[oldPositions[i]].second) {
             const auto uses = renamedDecl->uses();
             if (!uses.isEmpty()) {
                 renameActions << new RenameAction(renamedDecl->identifier(), newSignature.parameters[i].second,
                                                   RevisionedFileRanges::convert(uses));
             }
         }
     }
 
     return renameActions;
 }
 
 void AdaptSignatureAssistant::updateReady(const KDevelop::IndexedString& document, const KDevelop::ReferencedTopDUContext& top)
 {
     if (!top || !m_document || document.toUrl() != m_document->url() || top->url() != IndexedString(m_document->url())) {
         return;
     }
     clearActions();
 
     DUChainReadLocker lock;
 
     Declaration *functionDecl = getDeclarationAtCursor(m_lastEditPosition, m_document->url());
     if (!functionDecl || functionDecl->identifier() != m_declarationName) {
         clangDebug() << "No function found at" << m_document->url() << m_lastEditPosition;
         return;
     }
-    DUContext *functionCtxt = DUChainUtils::getFunctionContext(functionDecl);
+    DUContext *functionCtxt = DUChainUtils::functionContext(functionDecl);
     if (!functionCtxt) {
         clangDebug() << "No function context found for" << functionDecl->toString();
         return;
     }
 #if 0 // TODO: Port
     if (QtFunctionDeclaration * classFun = dynamic_cast<QtFunctionDeclaration*>(functionDecl)) {
         if (classFun->isSignal()) {
             // do not offer to change signature of a signal, as the implementation will be generated by moc
             return;
         }
     }
 #endif
 
     //ParseJob having finished, get the signature that was modified
     Signature newSignature = getDeclarationSignature(functionDecl, functionCtxt, false);
 
     //Check for changes between m_oldSignature and newSignature, use oldPositions to store old<->new param index mapping
     QList<int> oldPositions;
     if (!getSignatureChanges(newSignature, oldPositions)) {
         reset();
         clangDebug() << "no changes to signature";
         return; //No changes to signature
     }
     QList<RenameAction*> renameActions;
     if (m_editingDefinition) {
         setDefaultParams(newSignature, oldPositions); //restore default parameters before updating the declarations
     } else {
         renameActions = getRenameActions(newSignature, oldPositions);  //rename as needed when updating the definition
     }
     IAssistantAction::Ptr action(new AdaptSignatureAction(m_otherSideId, m_otherSideTopContext,
                                                           m_oldSignature, newSignature,
                                                           m_editingDefinition, renameActions));
     connect(action.data(), &IAssistantAction::executed,
             this, &AdaptSignatureAssistant::reset);
     addAction(action);
     emit actionsChanged();
 }
 
 KTextEditor::Range AdaptSignatureAssistant::displayRange() const
 {
     if (!m_document) {
         return {};
     }
 
     auto s = m_lastEditPosition;
     KTextEditor::Range ran = {s.line(), 0, s.line(), m_document->lineLength(s.line())};
     return ran;
 }
 
 #include "moc_adaptsignatureassistant.cpp"
diff --git a/plugins/clang/tests/test_duchain.cpp b/plugins/clang/tests/test_duchain.cpp
index 997fac9bee..64089e922f 100644
--- a/plugins/clang/tests/test_duchain.cpp
+++ b/plugins/clang/tests/test_duchain.cpp
@@ -1,2088 +1,2088 @@
 /*
  * Copyright 2014  Milian Wolff <mail@milianw.de>
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  * Copyright 2015  Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "test_duchain.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testfile.h>
 #include <tests/testproject.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/types/integraltype.h>
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/typealiastype.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/abstractfunctiondeclaration.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <language/duchain/forwarddeclaration.h>
 #include <language/duchain/use.h>
 #include <language/duchain/duchaindumper.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/idocumentcontroller.h>
 #include <util/kdevstringhandler.h>
 
 #include "duchain/clangparsingenvironmentfile.h"
 #include "duchain/clangparsingenvironment.h"
 #include "duchain/parsesession.h"
 
 #include <custom-definesandincludes/idefinesandincludesmanager.h>
 
 #include <KConfigGroup>
 
 #include <QTest>
 #include <QSignalSpy>
 #include <QLoggingCategory>
 #include <QThread>
 
 QTEST_MAIN(TestDUChain)
 
 using namespace KDevelop;
 
 class TestEnvironmentProvider final : public IDefinesAndIncludesManager::BackgroundProvider
 {
 public:
     ~TestEnvironmentProvider() override = default;
     QHash< QString, QString > definesInBackground(const QString& /*path*/) const override
     {
         return defines;
     }
 
     Path::List includesInBackground(const QString& /*path*/) const override
     {
         return includes;
     }
 
     Path::List frameworkDirectoriesInBackground(const QString&) const override
     {
         return {};
     }
 
     IDefinesAndIncludesManager::Type type() const override
     {
         return IDefinesAndIncludesManager::UserDefined;
     }
 
     QHash<QString, QString> defines;
     Path::List includes;
 };
 
 TestDUChain::~TestDUChain() = default;
 
 void TestDUChain::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
     AutoTestShell::init({QStringLiteral("kdevclangsupport")});
     auto core = TestCore::initialize();
     delete core->projectController();
     m_projectController = new TestProjectController(core);
     core->setProjectController(m_projectController);
 }
 
 void TestDUChain::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestDUChain::cleanup()
 {
     if (m_provider) {
         IDefinesAndIncludesManager::manager()->unregisterBackgroundProvider(m_provider.data());
     }
 }
 
 void TestDUChain::init()
 {
     m_provider.reset(new TestEnvironmentProvider);
     IDefinesAndIncludesManager::manager()->registerBackgroundProvider(m_provider.data());
 }
 
 struct ExpectedComment
 {
     QString identifier;
     QString comment;
 };
 Q_DECLARE_METATYPE(ExpectedComment)
 Q_DECLARE_METATYPE(AbstractType::WhichType)
 
 void TestDUChain::testComments()
 {
     QFETCH(QString, code);
     QFETCH(ExpectedComment, expectedComment);
 
     TestFile file(code, QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     auto candidates = top->findDeclarations(QualifiedIdentifier(expectedComment.identifier));
     QVERIFY(!candidates.isEmpty());
     auto decl = candidates.first();
     QString comment = QString::fromLocal8Bit(decl->comment());
     const auto plainText = KDevelop::htmlToPlainText(comment, KDevelop::CompleteMode);
     // if comment is e.g. "<this is bar", htmlToPlainText(comment) would just return an empty string; avoid this
     if (!plainText.isEmpty()) {
         comment = plainText;
     }
     QCOMPARE(comment, expectedComment.comment);
 }
 
 void TestDUChain::testComments_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<ExpectedComment>("expectedComment");
 
     // note: Clang only retrieves the comments when in doxygen-style format (i.e. '///', '/**', '///<')
     QTest::newRow("invalid1")
         << "//this is foo\nint foo;"
         << ExpectedComment{"foo", QString()};
     QTest::newRow("invalid2")
         << "/*this is foo*/\nint foo;"
         << ExpectedComment{"foo", QString()};
     QTest::newRow("basic1")
         << "///this is foo\nint foo;"
         << ExpectedComment{"foo", "this is foo"};
     QTest::newRow("basic2")
         << "/**this is foo*/\nint foo;"
         << ExpectedComment{"foo", "this is foo"};
 
     // as long as https://bugs.llvm.org/show_bug.cgi?id=35333 is not fixed, we don't fully parse and render
     // doxygen-style comments properly (cf. `makeComment` in builder.cpp)
 #define PARSE_COMMENTS 0
     QTest::newRow("enumerator")
         << "enum Foo { bar1, ///<this is bar1\nbar2 ///<this is bar2\n };"
 #if PARSE_COMMENTS
         << ExpectedComment{"Foo::bar1", "this is bar1"};
 #else
         << ExpectedComment{"Foo::bar1", "<this is bar1"};
 #endif
     QTest::newRow("comment-formatting")
         << "/** a\n * multiline\n *\n * comment\n */ int foo;"
 #if PARSE_COMMENTS
         << ExpectedComment{"foo", "a multiline\ncomment"};
 #else
         << ExpectedComment{"foo", "a multiline comment"};
 #endif
     QTest::newRow("comment-doxygen-tags")
         << "/** @see bar()\n@param a foo\n*/\nvoid foo(int a);\nvoid bar();"
 #if PARSE_COMMENTS
         << ExpectedComment{"foo", "bar()\na\nfoo"};
 #else
         << ExpectedComment{"foo", "@see bar() @param a foo"};
 #endif
 }
 
 void TestDUChain::testElaboratedType()
 {
     QFETCH(QString, code);
     QFETCH(AbstractType::WhichType, type);
 
     TestFile file(code, QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
     auto decl = file.topContext()->localDeclarations()[1];
     QVERIFY(decl);
 
     auto function = dynamic_cast<FunctionDeclaration*>(decl);
     QVERIFY(function);
 
     auto functionType = function->type<FunctionType>();
     QVERIFY(functionType);
 
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("namespace", "The ElaboratedType is not exposed through the libclang interface, not much we can do here", Abort);
 #endif
     QVERIFY(functionType->returnType()->whichType() != AbstractType::TypeDelayed);
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("typedef", "After using clang_getCanonicalType on ElaboratedType all typedef information get's stripped away", Continue);
 #endif
     QCOMPARE(functionType->returnType()->whichType(), type);
 }
 
 void TestDUChain::testElaboratedType_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<AbstractType::WhichType>("type");
 
     QTest::newRow("namespace")
         << "namespace NS{struct Type{};} struct NS::Type foo();"
         << AbstractType::TypeStructure;
     QTest::newRow("enum")
         << "enum Enum{}; enum Enum foo();"
         << AbstractType::TypeEnumeration;
     QTest::newRow("typedef")
         << "namespace NS{typedef int type;} NS::type foo();"
         << AbstractType::TypeAlias;
 }
 
 void TestDUChain::testInclude()
 {
     TestFile header(QStringLiteral("int foo() { return 42; }\n"), QStringLiteral("h"));
     // NOTE: header is _not_ explicitly being parsed, instead the impl job does that
 
     TestFile impl("#include \"" + header.url().str() + "\"\n"
                   "int main() { return foo(); }", QStringLiteral("cpp"), &header);
     impl.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     auto implCtx = impl.topContext();
     QVERIFY(implCtx);
 
     DUChainReadLocker lock;
     QCOMPARE(implCtx->localDeclarations().size(), 1);
 
     auto headerCtx = DUChain::self()->chainForDocument(header.url());
     QVERIFY(headerCtx);
     QVERIFY(!headerCtx->parsingEnvironmentFile()->needsUpdate());
     QCOMPARE(headerCtx->localDeclarations().size(), 1);
 
     QVERIFY(implCtx->imports(headerCtx, CursorInRevision(0, 10)));
 
     Declaration* foo = headerCtx->localDeclarations().first();
     QCOMPARE(foo->uses().size(), 1);
     QCOMPARE(foo->uses().begin().key(), impl.url());
     QCOMPARE(foo->uses().begin()->size(), 1);
     QCOMPARE(foo->uses().begin()->first(), RangeInRevision(1, 20, 1, 23));
 }
 
 void TestDUChain::testMissingInclude()
 {
     auto code = R"(
 #pragma once
 #include "missing1.h"
 
 template<class T>
 class A
 {
     T a;
 };
 
 #include "missing2.h"
 
 class B : public A<int>
 {
 };
     )";
 
     TestFile header(code, QStringLiteral("h"));
     TestFile impl("#include \"" + header.url().str() + "\"\n", QStringLiteral("cpp"), &header);
     QVERIFY(impl.parseAndWait(TopDUContext::AllDeclarationsContextsAndUses));
 
     DUChainReadLocker lock;
 
     auto top = impl.topContext();
     QVERIFY(top);
 
     QCOMPARE(top->importedParentContexts().count(), 1);
 
     TopDUContext* headerCtx = dynamic_cast<TopDUContext*>(top->importedParentContexts().first().context(top));
     QVERIFY(headerCtx);
     QCOMPARE(headerCtx->url(), header.url());
 
 #if CINDEX_VERSION_MINOR < 34
     QEXPECT_FAIL("", "Second missing header isn't reported", Continue);
 #endif
     QCOMPARE(headerCtx->problems().count(), 2);
 
     QCOMPARE(headerCtx->localDeclarations().count(), 2);
 
     auto a = dynamic_cast<ClassDeclaration*>(headerCtx->localDeclarations().first());
     QVERIFY(a);
 
     auto b = dynamic_cast<ClassDeclaration*>(headerCtx->localDeclarations().last());
     QVERIFY(b);
 
     // NOTE: This fails and needs fixing. If the include of "missing2.h"
     //       above is commented out, then it doesn't fail. Maybe
     //       clang stops processing when it encounters the second missing
     //       header, or similar.
     // XFAIL this check until https://bugs.llvm.org/show_bug.cgi?id=38155 is fixed
     QEXPECT_FAIL("", "Base class isn't assigned correctly", Continue);
     QCOMPARE(b->baseClassesSize(), 1u);
 
 #if CINDEX_VERSION_MINOR < 34
     // at least the one problem we have should have been propagated
     QCOMPARE(top->problems().count(), 1);
 #else
     // two errors:
     // /tmp/testfile_f32415.h:3:10: error: 'missing1.h' file not found
     // /tmp/testfile_f32415.h:11:10: error: 'missing2.h' file not found
     QCOMPARE(top->problems().count(), 2);
 #endif
 }
 
 QByteArray createCode(const QByteArray& prefix, const int functions)
 {
     QByteArray code;
     code += "#ifndef " + prefix + "_H\n";
     code += "#define " + prefix + "_H\n";
     for (int i = 0; i < functions; ++i) {
         code += "void myFunc_" + prefix + "(int arg1, char arg2, const char* arg3);\n";
     }
     code += "#endif\n";
     return code;
 }
 
 void TestDUChain::testIncludeLocking()
 {
     TestFile header1(createCode("Header1", 1000), QStringLiteral("h"));
     TestFile header2(createCode("Header2", 1000), QStringLiteral("h"));
     TestFile header3(createCode("Header3", 1000), QStringLiteral("h"));
 
     ICore::self()->languageController()->backgroundParser()->setThreadCount(3);
 
     TestFile impl1("#include \"" + header1.url().str() + "\"\n"
                    "#include \"" + header2.url().str() + "\"\n"
                    "#include \"" + header3.url().str() + "\"\n"
                    "int main() { return 0; }", QStringLiteral("cpp"));
 
     TestFile impl2("#include \"" + header2.url().str() + "\"\n"
                    "#include \"" + header1.url().str() + "\"\n"
                    "#include \"" + header3.url().str() + "\"\n"
                    "int main() { return 0; }", QStringLiteral("cpp"));
 
     TestFile impl3("#include \"" + header3.url().str() + "\"\n"
                    "#include \"" + header1.url().str() + "\"\n"
                    "#include \"" + header2.url().str() + "\"\n"
                    "int main() { return 0; }", QStringLiteral("cpp"));
 
     impl1.parse(TopDUContext::AllDeclarationsContextsAndUses);
     impl2.parse(TopDUContext::AllDeclarationsContextsAndUses);
     impl3.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(impl1.waitForParsed(5000));
     QVERIFY(impl2.waitForParsed(5000));
     QVERIFY(impl3.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(DUChain::self()->chainForDocument(header1.url()));
     QVERIFY(DUChain::self()->chainForDocument(header2.url()));
     QVERIFY(DUChain::self()->chainForDocument(header3.url()));
 }
 
 void TestDUChain::testReparse()
 {
     TestFile file(QStringLiteral("int main() { int i = 42; return i; }"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     DeclarationPointer mainDecl;
     DeclarationPointer iDecl;
     for (int i = 0; i < 3; ++i) {
         QVERIFY(file.waitForParsed(500));
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 1);
         QCOMPARE(file.topContext()->localDeclarations().size(), 1);
         DUContext *exprContext = file.topContext()->childContexts().first()->childContexts().first();
         QCOMPARE(exprContext->localDeclarations().size(), 1);
 
         if (i) {
             QVERIFY(mainDecl);
             QCOMPARE(mainDecl.data(), file.topContext()->localDeclarations().first());
 
             QVERIFY(iDecl);
             QCOMPARE(iDecl.data(), exprContext->localDeclarations().first());
         }
         mainDecl = file.topContext()->localDeclarations().first();
         iDecl = exprContext->localDeclarations().first();
 
         QVERIFY(mainDecl->uses().isEmpty());
         QCOMPARE(iDecl->uses().size(), 1);
         QCOMPARE(iDecl->uses().begin()->size(), 1);
 
         if (i == 1) {
             file.setFileContents(QStringLiteral("int main()\n{\nfloat i = 13; return i - 5;\n}\n"));
         }
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testReparseError()
 {
     TestFile file(QStringLiteral("int i = 1 / 0;\n"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     for (int i = 0; i < 2; ++i) {
         QVERIFY(file.waitForParsed(500));
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         if (!i) {
             QCOMPARE(file.topContext()->problems().size(), 1);
             file.setFileContents(QStringLiteral("int i = 0;\n"));
         } else {
             QCOMPARE(file.topContext()->problems().size(), 0);
         }
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testTemplate()
 {
     TestFile file("template<typename T> struct foo { T bar; };\n"
                   "int main() { foo<int> myFoo; return myFoo.bar; }\n", QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto fooDecl = file.topContext()->localDeclarations().first();
     QVERIFY(fooDecl->internalContext());
     QCOMPARE(fooDecl->internalContext()->localDeclarations().size(), 2);
 
     QCOMPARE(file.topContext()->findDeclarations(QualifiedIdentifier("foo< T >")).size(), 1);
     QCOMPARE(file.topContext()->findDeclarations(QualifiedIdentifier("foo< T >::bar")).size(), 1);
 
     auto mainCtx = file.topContext()->localDeclarations().last()->internalContext()->childContexts().first();
     QVERIFY(mainCtx);
     auto myFoo = mainCtx->localDeclarations().first();
     QVERIFY(myFoo);
     QCOMPARE(myFoo->abstractType()->toString().remove(' '), QStringLiteral("foo<int>"));
 }
 
 void TestDUChain::testNamespace()
 {
     TestFile file("namespace foo { struct bar { int baz; }; }\n"
                   "int main() { foo::bar myBar; }\n", QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto fooDecl = file.topContext()->localDeclarations().first();
     QVERIFY(fooDecl->internalContext());
     QCOMPARE(fooDecl->internalContext()->localDeclarations().size(), 1);
 
     DUContext* top = file.topContext().data();
     DUContext* mainCtx = file.topContext()->childContexts().last();
 
     auto foo = top->localDeclarations().first();
     QCOMPARE(foo->qualifiedIdentifier().toString(), QString("foo"));
 
     DUContext* fooCtx = file.topContext()->childContexts().first();
     QCOMPARE(fooCtx->localScopeIdentifier().toString(), QString("foo"));
     QCOMPARE(fooCtx->scopeIdentifier(true).toString(), QString("foo"));
     QCOMPARE(fooCtx->localDeclarations().size(), 1);
     auto bar = fooCtx->localDeclarations().first();
     QCOMPARE(bar->qualifiedIdentifier().toString(), QString("foo::bar"));
     QCOMPARE(fooCtx->childContexts().size(), 1);
 
     DUContext* barCtx = fooCtx->childContexts().first();
     QCOMPARE(barCtx->localScopeIdentifier().toString(), QString("bar"));
     QCOMPARE(barCtx->scopeIdentifier(true).toString(), QString("foo::bar"));
     QCOMPARE(barCtx->localDeclarations().size(), 1);
     auto baz = barCtx->localDeclarations().first();
     QCOMPARE(baz->qualifiedIdentifier().toString(), QString("foo::bar::baz"));
 
     for (auto ctx : {top, mainCtx}) {
         QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo")).size(), 1);
         QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo::bar")).size(), 1);
         QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo::bar::baz")).size(), 1);
     }
 }
 
 void TestDUChain::testAutoTypeDeduction()
 {
     TestFile file(QStringLiteral(R"(
         const volatile auto foo = 5;
         template<class T> struct myTemplate {};
         myTemplate<myTemplate<int>& > templRefParam;
         auto autoTemplRefParam = templRefParam;
     )"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
 
     DUContext* ctx = file.topContext().data();
     QVERIFY(ctx);
     QCOMPARE(ctx->localDeclarations().size(), 4);
     QCOMPARE(ctx->findDeclarations(QualifiedIdentifier("foo")).size(), 1);
     Declaration* decl = ctx->findDeclarations(QualifiedIdentifier(QStringLiteral("foo")))[0];
     QCOMPARE(decl->identifier(), Identifier("foo"));
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "No type deduction here unfortunately, missing API in Clang", Continue);
 #endif
     QVERIFY(decl->type<IntegralType>());
 #if CINDEX_VERSION_MINOR < 31
     QCOMPARE(decl->toString(), QStringLiteral("const volatile auto foo"));
 #else
     QCOMPARE(decl->toString(), QStringLiteral("const volatile int foo"));
 #endif
 
     decl = ctx->findDeclarations(QualifiedIdentifier(QStringLiteral("autoTemplRefParam")))[0];
     QVERIFY(decl);
     QVERIFY(decl->abstractType());
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "Auto type is not exposed via LibClang", Continue);
 #endif
     QCOMPARE(decl->abstractType()->toString(), QStringLiteral("myTemplate< myTemplate< int >& >"));
 }
 
 void TestDUChain::testTypeDeductionInTemplateInstantiation()
 {
     // see: http://clang-developers.42468.n3.nabble.com/RFC-missing-libclang-query-functions-features-td2504253.html
     TestFile file(QStringLiteral("template<typename T> struct foo { T member; } foo<int> f; auto i = f.member;"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
 
     DUContext* ctx = file.topContext().data();
     QVERIFY(ctx);
     QCOMPARE(ctx->localDeclarations().size(), 3);
     Declaration* decl = nullptr;
 
     // check 'foo' declaration
     decl = ctx->localDeclarations()[0];
     QVERIFY(decl);
     QCOMPARE(decl->identifier(), Identifier("foo< T >"));
 
     // check type of 'member' inside declaration-scope
     QCOMPARE(ctx->childContexts().size(), 1);
     DUContext* fooCtx = ctx->childContexts().first();
     QVERIFY(fooCtx);
     // Should there really be two declarations?
     QCOMPARE(fooCtx->localDeclarations().size(), 2);
     decl = fooCtx->localDeclarations()[1];
     QCOMPARE(decl->identifier(), Identifier("member"));
 
     // check type of 'member' in definition of 'f'
     decl = ctx->localDeclarations()[1];
     QCOMPARE(decl->identifier(), Identifier("f"));
     decl = ctx->localDeclarations()[2];
     QCOMPARE(decl->identifier(), Identifier("i"));
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "No type deduction here unfortunately, missing API in Clang", Continue);
 #endif
     QVERIFY(decl->type<IntegralType>());
 }
 
 void TestDUChain::testVirtualMemberFunction()
 {
     //Forward-declarations with "struct" or "class" are considered equal, so make sure the override is detected correctly.
     TestFile file(QStringLiteral("struct S {}; struct A { virtual S* ret(); }; struct B : public A { virtual S* ret(); };"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     DUContext* top = file.topContext().data();
     QVERIFY(top);
 
     QCOMPARE(top->childContexts().count(), 3);
     QCOMPARE(top->localDeclarations().count(), 3);
     QCOMPARE(top->childContexts()[2]->localDeclarations().count(), 1);
     Declaration* decl = top->childContexts()[2]->localDeclarations()[0];
     QCOMPARE(decl->identifier(), Identifier("ret"));
-    QVERIFY(DUChainUtils::getOverridden(decl));
+    QVERIFY(DUChainUtils::overridden(decl));
 }
 
 void TestDUChain::testBaseClasses()
 {
     TestFile file(QStringLiteral("class Base {}; class Inherited : public Base {};"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     DUContext* top = file.topContext().data();
     QVERIFY(top);
 
     QCOMPARE(top->localDeclarations().count(), 2);
     Declaration* baseDecl = top->localDeclarations().first();
     QCOMPARE(baseDecl->identifier(), Identifier("Base"));
 
     ClassDeclaration* inheritedDecl = dynamic_cast<ClassDeclaration*>(top->localDeclarations()[1]);
     QCOMPARE(inheritedDecl->identifier(), Identifier("Inherited"));
 
     QVERIFY(inheritedDecl);
     QCOMPARE(inheritedDecl->baseClassesSize(), 1u);
 
     QCOMPARE(baseDecl->uses().count(), 1);
     QCOMPARE(baseDecl->uses().first().count(), 1);
     QCOMPARE(baseDecl->uses().first().first(), RangeInRevision(0, 40, 0, 44));
 }
 
 void TestDUChain::testReparseBaseClasses()
 {
     TestFile file(QStringLiteral("struct a{}; struct b : a {};\n"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     for (int i = 0; i < 2; ++i) {
         qDebug() << "run: " << i;
         QVERIFY(file.waitForParsed(500));
         DUChainWriteLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->childContexts().first()->importers().size(), 1);
         QCOMPARE(file.topContext()->childContexts().last()->importedParentContexts().size(), 1);
 
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
         auto aDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().first());
         QVERIFY(aDecl);
         QCOMPARE(aDecl->baseClassesSize(), 0u);
         auto bDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().last());
         QVERIFY(bDecl);
         QCOMPARE(bDecl->baseClassesSize(), 1u);
         int distance = 0;
         QVERIFY(bDecl->isPublicBaseClass(aDecl, file.topContext(), &distance));
         QCOMPARE(distance, 1);
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testReparseBaseClassesTemplates()
 {
     TestFile file(QStringLiteral("template<typename T> struct a{}; struct b : a<int> {};\n"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     for (int i = 0; i < 2; ++i) {
         qDebug() << "run: " << i;
         QVERIFY(file.waitForParsed(500));
         DUChainWriteLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->childContexts().first()->importers().size(), 1);
         QCOMPARE(file.topContext()->childContexts().last()->importedParentContexts().size(), 1);
 
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
         auto aDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().first());
         QVERIFY(aDecl);
         QCOMPARE(aDecl->baseClassesSize(), 0u);
         auto bDecl = dynamic_cast<ClassDeclaration*>(file.topContext()->localDeclarations().last());
         QVERIFY(bDecl);
         QCOMPARE(bDecl->baseClassesSize(), 1u);
         int distance = 0;
         QVERIFY(bDecl->isPublicBaseClass(aDecl, file.topContext(), &distance));
         QCOMPARE(distance, 1);
 
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     }
 }
 
 void TestDUChain::testGetInheriters_data()
 {
     QTest::addColumn<QString>("code");
 
     QTest::newRow("inline") << "struct Base { struct Inner {}; }; struct Inherited : Base, Base::Inner {};";
     QTest::newRow("outline") << "struct Base { struct Inner; }; struct Base::Inner {}; struct Inherited : Base, Base::Inner {};";
 }
 
 void TestDUChain::testGetInheriters()
 {
     QFETCH(QString, code);
     TestFile file(code, QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     QVERIFY(top->problems().isEmpty());
 
     QCOMPARE(top->localDeclarations().count(), 2);
     Declaration* baseDecl = top->localDeclarations().first();
     QCOMPARE(baseDecl->identifier(), Identifier("Base"));
 
     DUContext* baseCtx = baseDecl->internalContext();
     QVERIFY(baseCtx);
     QCOMPARE(baseCtx->localDeclarations().count(), 1);
 
     Declaration* innerDecl = baseCtx->localDeclarations().first();
     QCOMPARE(innerDecl->identifier(), Identifier("Inner"));
     if (auto forward = dynamic_cast<ForwardDeclaration*>(innerDecl)) {
         innerDecl = forward->resolve(top);
     }
     QVERIFY(dynamic_cast<ClassDeclaration*>(innerDecl));
 
     Declaration* inheritedDecl = top->localDeclarations().last();
     QVERIFY(inheritedDecl);
     QCOMPARE(inheritedDecl->identifier(), Identifier("Inherited"));
 
     uint maxAllowedSteps = uint(-1);
-    auto baseInheriters = DUChainUtils::getInheriters(baseDecl, maxAllowedSteps);
+    auto baseInheriters = DUChainUtils::inheriters(baseDecl, maxAllowedSteps);
     QCOMPARE(baseInheriters, QList<Declaration*>() << inheritedDecl);
 
     maxAllowedSteps = uint(-1);
-    auto innerInheriters = DUChainUtils::getInheriters(innerDecl, maxAllowedSteps);
+    auto innerInheriters = DUChainUtils::inheriters(innerDecl, maxAllowedSteps);
     QCOMPARE(innerInheriters, QList<Declaration*>() << inheritedDecl);
 
     maxAllowedSteps = uint(-1);
-    auto inheritedInheriters = DUChainUtils::getInheriters(inheritedDecl, maxAllowedSteps);
+    auto inheritedInheriters = DUChainUtils::inheriters(inheritedDecl, maxAllowedSteps);
     QCOMPARE(inheritedInheriters.count(), 0);
 }
 
 void TestDUChain::testGlobalFunctionDeclaration()
 {
     TestFile file(QStringLiteral("void foo(int arg1, char arg2);\n"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     file.waitForParsed();
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 1);
     QCOMPARE(file.topContext()->childContexts().size(), 1);
     QVERIFY(!file.topContext()->childContexts().first()->inSymbolTable());
 }
 
 void TestDUChain::testFunctionDefinitionVsDeclaration()
 {
     TestFile file(QStringLiteral("void func(); void func() {}\n"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto funcDecl = file.topContext()->localDeclarations()[0];
     QVERIFY(!funcDecl->isDefinition());
     QVERIFY(!dynamic_cast<FunctionDefinition*>(funcDecl));
     auto funcDef = file.topContext()->localDeclarations()[1];
     QVERIFY(dynamic_cast<FunctionDefinition*>(funcDef));
     QVERIFY(funcDef->isDefinition());
 }
 
 void TestDUChain::testEnsureNoDoubleVisit()
 {
     // On some language construct, we may up visiting the same cursor multiple times
     // Example: "struct SomeStruct {} s;"
     // decl: "SomeStruct SomeStruct " of kind StructDecl (2) in main.cpp@[(1,1),(1,17)]
     // decl: "struct SomeStruct s " of kind VarDecl (9) in main.cpp@[(1,1),(1,19)]
     // decl: "SomeStruct SomeStruct " of kind StructDecl (2) in main.cpp@[(1,1),(1,17)]
     //
     // => We end up visiting the StructDecl twice (or more)
     //    That's because we use clang_visitChildren not just on the translation unit cursor.
     //    Apparently just "recursing" vs. "visiting children explicitly"
     //    results in a different AST traversal
 
     TestFile file(QStringLiteral("struct SomeStruct {} s;\n"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
 
     // there should only be one declaration for "SomeStruct"
     auto candidates = top->findDeclarations(QualifiedIdentifier(QStringLiteral("SomeStruct")));
     QCOMPARE(candidates.size(), 1);
 }
 
 void TestDUChain::testParsingEnvironment()
 {
     const TopDUContext::Features features = TopDUContext::AllDeclarationsContextsAndUses;
 
     IndexedTopDUContext indexed;
     ClangParsingEnvironment lastEnv;
     {
         TestFile file(QStringLiteral("int main() {}\n"), QStringLiteral("cpp"));
         auto astFeatures = static_cast<TopDUContext::Features>(features | TopDUContext::AST);
         file.parse(astFeatures);
         file.setKeepDUChainData(true);
         QVERIFY(file.waitForParsed());
 
         DUChainWriteLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
         auto sessionData = ParseSessionData::Ptr(dynamic_cast<ParseSessionData*>(top->ast().data()));
         lock.unlock();
         ParseSession session(sessionData);
         lock.lock();
         QVERIFY(session.data());
         QVERIFY(top);
 
         auto envFile = QExplicitlySharedDataPointer<ClangParsingEnvironmentFile>(
             dynamic_cast<ClangParsingEnvironmentFile*>(file.topContext()->parsingEnvironmentFile().data()));
 
         QCOMPARE(envFile->features(), astFeatures);
         QVERIFY(envFile->featuresSatisfied(astFeatures));
         QCOMPARE(envFile->environmentQuality(), ClangParsingEnvironment::Source);
 
         // if no environment is given, no update should be triggered
         QVERIFY(!envFile->needsUpdate());
 
         // same env should also not trigger a reparse
         ClangParsingEnvironment env = session.environment();
         QCOMPARE(env.quality(), ClangParsingEnvironment::Source);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // but changing the environment should trigger an update
         env.addIncludes(Path::List() << Path(QStringLiteral("/foo/bar/baz")));
         QVERIFY(envFile->needsUpdate(&env));
         envFile->setEnvironment(env);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // setting the environment quality higher should require an update
         env.setQuality(ClangParsingEnvironment::BuildSystem);
         QVERIFY(envFile->needsUpdate(&env));
         envFile->setEnvironment(env);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // changing defines requires an update
         env.addDefines(QHash<QString, QString>{ { "foo", "bar" } });
         QVERIFY(envFile->needsUpdate(&env));
 
         // but only when changing the defines for the envFile's TU
         const auto barTU = IndexedString("bar.cpp");
         const auto oldTU = env.translationUnitUrl();
         env.setTranslationUnitUrl(barTU);
         QCOMPARE(env.translationUnitUrl(), barTU);
         QVERIFY(!envFile->needsUpdate(&env));
         env.setTranslationUnitUrl(oldTU);
         QVERIFY(envFile->needsUpdate(&env));
 
         // update it again
         envFile->setEnvironment(env);
         QVERIFY(!envFile->needsUpdate(&env));
         lastEnv = env;
 
         // now compare against a lower quality environment
         // in such a case, we do not want to trigger an update
         env.setQuality(ClangParsingEnvironment::Unknown);
         env.setTranslationUnitUrl(barTU);
         QVERIFY(!envFile->needsUpdate(&env));
 
         // even when the environment changes
         env.addIncludes(Path::List() << Path(QStringLiteral("/lalalala")));
         QVERIFY(!envFile->needsUpdate(&env));
 
         indexed = top->indexed();
     }
 
     DUChain::self()->storeToDisk();
 
     {
         DUChainWriteLocker lock;
         QVERIFY(!DUChain::self()->isInMemory(indexed.index()));
         QVERIFY(indexed.data());
         QVERIFY(DUChain::self()->environmentFileForDocument(indexed));
         auto envFile = QExplicitlySharedDataPointer<ClangParsingEnvironmentFile>(
             dynamic_cast<ClangParsingEnvironmentFile*>(DUChain::self()->environmentFileForDocument(indexed).data()));
         QVERIFY(envFile);
 
         QCOMPARE(envFile->features(), features);
         QVERIFY(envFile->featuresSatisfied(features));
         QVERIFY(!envFile->needsUpdate(&lastEnv));
         DUChain::self()->removeDocumentChain(indexed.data());
     }
 }
 
 void TestDUChain::testActiveDocumentHasASTAttached()
 {
   const TopDUContext::Features features = TopDUContext::AllDeclarationsContextsAndUses;
 
     IndexedTopDUContext indexed;
     ClangParsingEnvironment lastEnv;
     {
         TestFile file(QStringLiteral("int main() {}\n"), QStringLiteral("cpp"));
         auto astFeatures = static_cast<TopDUContext::Features>(features | TopDUContext::AST);
         file.parse(astFeatures);
         file.setKeepDUChainData(true);
         QVERIFY(file.waitForParsed());
 
         DUChainWriteLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
         auto sessionData = ParseSessionData::Ptr(dynamic_cast<ParseSessionData*>(top->ast().data()));
         lock.unlock();
         ParseSession session(sessionData);
         lock.lock();
         QVERIFY(session.data());
         QVERIFY(top);
         QVERIFY(top->ast());
 
         indexed = top->indexed();
     }
 
     DUChain::self()->storeToDisk();
 
     {
         DUChainWriteLocker lock;
         QVERIFY(!DUChain::self()->isInMemory(indexed.index()));
         QVERIFY(indexed.data());
     }
 
     QUrl url;
     {
         DUChainReadLocker lock;
         auto ctx = indexed.data();
         QVERIFY(ctx);
         QVERIFY(!ctx->ast());
         url = ctx->url().toUrl();
     }
 
     QVERIFY(!QFileInfo::exists(url.toLocalFile()));
     QFile file(url.toLocalFile());
     file.open(QIODevice::WriteOnly);
     Q_ASSERT(file.isOpen());
 
     auto document = ICore::self()->documentController()->openDocument(url);
     QVERIFY(document);
     ICore::self()->documentController()->activateDocument(document);
 
     QApplication::processEvents();
     ICore::self()->languageController()->backgroundParser()->parseDocuments();
     QThread::sleep(1);
 
     document->close(KDevelop::IDocument::Discard);
     {
         DUChainReadLocker lock;
         auto ctx = indexed.data();
         QVERIFY(ctx);
         QVERIFY(ctx->ast());
     }
 
     DUChainWriteLocker lock;
     DUChain::self()->removeDocumentChain(indexed.data());
 }
 
 void TestDUChain::testActiveDocumentsGetBestPriority()
 {
     // note: this test would make more sense in kdevplatform, but we don't have a language plugin available there
     // (required for background parsing)
     // TODO: Create a fake-language plugin in kdevplatform for testing purposes, use that.
 
     TestFile file1(QStringLiteral("int main() {}\n"), QStringLiteral("cpp"));
     TestFile file2(QStringLiteral("int main() {}\n"), QStringLiteral("cpp"));
     TestFile file3(QStringLiteral("int main() {}\n"), QStringLiteral("cpp"));
 
     DUChain::self()->storeToDisk();
 
     auto backgroundParser = ICore::self()->languageController()->backgroundParser();
     QVERIFY(!backgroundParser->isQueued(file1.url()));
 
     auto documentController = ICore::self()->documentController();
 
     // open first document (no activation)
     auto doc = documentController->openDocument(file1.url().toUrl(), KTextEditor::Range::invalid(), {IDocumentController::DoNotActivate});
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file1.url()));
     QCOMPARE(backgroundParser->priorityForDocument(file1.url()), (int)BackgroundParser::NormalPriority);
 
     // open second document, activate
     doc = documentController->openDocument(file2.url().toUrl());
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file2.url()));
     QCOMPARE(backgroundParser->priorityForDocument(file2.url()), (int)BackgroundParser::BestPriority);
 
     // open third document, activate, too
     doc = documentController->openDocument(file3.url().toUrl());
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file3.url()));
     QCOMPARE(backgroundParser->priorityForDocument(file3.url()), (int)BackgroundParser::BestPriority);
 }
 
 void TestDUChain::testSystemIncludes()
 {
     ClangParsingEnvironment env;
 
     Path::List projectIncludes = {
         Path("/projects/1"),
         Path("/projects/1/sub"),
         Path("/projects/2"),
         Path("/projects/2/sub")
     };
     env.addIncludes(projectIncludes);
     auto includes = env.includes();
     // no project paths set, so everything is considered a system include
     QCOMPARE(includes.system, projectIncludes);
     QVERIFY(includes.project.isEmpty());
 
     Path::List systemIncludes = {
         Path("/sys"),
         Path("/sys/sub")
     };
     env.addIncludes(systemIncludes);
     includes = env.includes();
     QCOMPARE(includes.system, projectIncludes + systemIncludes);
     QVERIFY(includes.project.isEmpty());
 
     Path::List projects = {
         Path("/projects/1"),
         Path("/projects/2")
     };
     env.setProjectPaths(projects);
     // now the list should be properly separated
     QCOMPARE(env.projectPaths(), projects);
     includes = env.includes();
     QCOMPARE(includes.system, systemIncludes);
     QCOMPARE(includes.project, projectIncludes);
 }
 
 void TestDUChain::testReparseWithAllDeclarationsContextsAndUses()
 {
     TestFile file(QStringLiteral("int foo() { return 0; } int main() { return foo(); }"), QStringLiteral("cpp"));
     file.parse(TopDUContext::VisibleDeclarationsAndContexts);
 
     QVERIFY(file.waitForParsed(1000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
         auto dec = file.topContext()->localDeclarations().at(0);
         QEXPECT_FAIL("", "Skipping of function bodies is disabled for now", Continue);
         QVERIFY(dec->uses().isEmpty());
     }
 
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(500));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->childContexts().size(), 2);
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
         auto mainDecl = file.topContext()->localDeclarations()[1];
         QVERIFY(mainDecl->uses().isEmpty());
         auto foo = file.topContext()->localDeclarations().first();
         QCOMPARE(foo->uses().size(), 1);
     }
 }
 
 void TestDUChain::testReparseOnDocumentActivated()
 {
     TestFile file(QStringLiteral("int foo() { return 0; } int main() { return foo(); }"), QStringLiteral("cpp"));
     file.parse(TopDUContext::VisibleDeclarationsAndContexts);
 
     QVERIFY(file.waitForParsed(1000));
 
     {
         DUChainReadLocker lock;
         auto ctx = file.topContext();
         QVERIFY(ctx);
         QCOMPARE(ctx->childContexts().size(), 2);
         QCOMPARE(ctx->localDeclarations().size(), 2);
 
         auto dec = ctx->localDeclarations().at(0);
         QEXPECT_FAIL("", "Skipping of function bodies was disabled for now", Continue);
         QVERIFY(dec->uses().isEmpty());
 
         QVERIFY(!ctx->ast());
     }
 
     auto backgroundParser = ICore::self()->languageController()->backgroundParser();
     QVERIFY(!backgroundParser->isQueued(file.url()));
 
     auto doc = ICore::self()->documentController()->openDocument(file.url().toUrl());
     QVERIFY(doc);
     QVERIFY(backgroundParser->isQueued(file.url()));
 
     QSignalSpy spy(backgroundParser, &BackgroundParser::parseJobFinished);
     spy.wait();
 
     doc->close(KDevelop::IDocument::Discard);
 
     {
         DUChainReadLocker lock;
         auto ctx = file.topContext();
         QCOMPARE(ctx->features() & TopDUContext::AllDeclarationsContextsAndUses, static_cast<int>(TopDUContext::AllDeclarationsContextsAndUses));
         QVERIFY(ctx->topContext()->ast());
     }
 }
 
 void TestDUChain::testReparseInclude()
 {
     TestFile header(QStringLiteral("int foo() { return 42; }\n"), QStringLiteral("h"));
     TestFile impl("#include \"" + header.url().str() + "\"\n"
                   "int main() { return foo(); }", QStringLiteral("cpp"), &header);
 
     // Use TopDUContext::AST to imitate that document is opened in the editor, so that ClangParseJob can store translation unit, that'll be used for reparsing.
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsAndContexts|TopDUContext::AST));
     QVERIFY(impl.waitForParsed(5000));
     {
         DUChainReadLocker lock;
         auto implCtx = impl.topContext();
         QVERIFY(implCtx);
         QCOMPARE(implCtx->importedParentContexts().size(), 1);
     }
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST));
     QVERIFY(impl.waitForParsed(5000));
 
     DUChainReadLocker lock;
     auto implCtx = impl.topContext();
     QVERIFY(implCtx);
     QCOMPARE(implCtx->localDeclarations().size(), 1);
 
     QCOMPARE(implCtx->importedParentContexts().size(), 1);
 
     auto headerCtx = DUChain::self()->chainForDocument(header.url());
     QVERIFY(headerCtx);
     QVERIFY(!headerCtx->parsingEnvironmentFile()->needsUpdate());
     QCOMPARE(headerCtx->localDeclarations().size(), 1);
 
     QVERIFY(implCtx->imports(headerCtx, CursorInRevision(0, 10)));
 
     Declaration* foo = headerCtx->localDeclarations().first();
     QCOMPARE(foo->uses().size(), 1);
     QCOMPARE(foo->uses().begin().key(), impl.url());
     QCOMPARE(foo->uses().begin()->size(), 1);
     QCOMPARE(foo->uses().begin()->first(), RangeInRevision(1, 20, 1, 23));
 
     QCOMPARE(DUChain::self()->allEnvironmentFiles(header.url()).size(), 1);
     QCOMPARE(DUChain::self()->allEnvironmentFiles(impl.url()).size(), 1);
     QCOMPARE(DUChain::self()->chainsForDocument(header.url()).size(), 1);
     QCOMPARE(DUChain::self()->chainsForDocument(impl.url()).size(), 1);
 }
 
 void TestDUChain::testReparseChangeEnvironment()
 {
     TestFile header(QStringLiteral("int foo() { return 42; }\n"), QStringLiteral("h"));
     TestFile impl("#include \"" + header.url().str() + "\"\n"
                   "int main() { return foo(); }", QStringLiteral("cpp"), &header);
 
     uint hashes[3] = {0, 0, 0};
 
     for (int i = 0; i < 3; ++i) {
         impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
         QVERIFY(impl.waitForParsed(5000));
 
         {
             DUChainReadLocker lock;
             QVERIFY(impl.topContext());
             auto env = dynamic_cast<ClangParsingEnvironmentFile*>(impl.topContext()->parsingEnvironmentFile().data());
             QVERIFY(env);
             QCOMPARE(env->environmentQuality(), ClangParsingEnvironment::Source);
             hashes[i] = env->environmentHash();
             QVERIFY(hashes[i]);
 
             // we should never end up with multiple env files or chains in memory for these files
             QCOMPARE(DUChain::self()->allEnvironmentFiles(impl.url()).size(), 1);
             QCOMPARE(DUChain::self()->chainsForDocument(impl.url()).size(), 1);
             QCOMPARE(DUChain::self()->allEnvironmentFiles(header.url()).size(), 1);
             QCOMPARE(DUChain::self()->chainsForDocument(header.url()).size(), 1);
         }
 
         // in every run, we expect the environment to have changed
         for (int j = 0; j < i; ++j) {
             QVERIFY(hashes[i] != hashes[j]);
         }
 
         if (i == 0) {
             // 1) change defines
             m_provider->defines.insert(QStringLiteral("foooooooo"), QStringLiteral("baaar!"));
         } else if (i == 1) {
             // 2) change includes
             m_provider->includes.append(Path(QStringLiteral("/foo/bar/asdf/lalala")));
         } // 3) stop
     }
 }
 
 void TestDUChain::testMacroDependentHeader()
 {
     TestFile header(QStringLiteral("struct MY_CLASS { class Q{Q(); int m;}; int m; };\n"), QStringLiteral("h"));
     TestFile impl("#define MY_CLASS A\n"
                   "#include \"" + header.url().str() + "\"\n"
                   "#undef MY_CLASS\n"
                   "#define MY_CLASS B\n"
                   "#include \"" + header.url().str() + "\"\n"
                   "#undef MY_CLASS\n"
                   "A a;\n"
                   "const A::Q aq;\n"
                   "B b;\n"
                   "const B::Q bq;\n"
                   "int am = a.m;\n"
                   "int aqm = aq.m;\n"
                   "int bm = b.m;\n"
                   "int bqm = bq.m;\n"
                   , QStringLiteral("cpp"), &header);
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(impl.waitForParsed(500000));
 
     DUChainReadLocker lock;
     TopDUContext* top = impl.topContext().data();
     QVERIFY(top);
     QCOMPARE(top->localDeclarations().size(), 10); // 2x macro, then a, aq, b, bq
     QCOMPARE(top->importedParentContexts().size(), 1);
     AbstractType::Ptr type = top->localDeclarations()[2]->abstractType();
     StructureType* sType = dynamic_cast<StructureType*>(type.data());
     QVERIFY(sType);
     QCOMPARE(sType->toString(), QString("A"));
     Declaration* decl = sType->declaration(top);
     QVERIFY(decl);
     AbstractType::Ptr type2 = top->localDeclarations()[4]->abstractType();
     StructureType* sType2 = dynamic_cast<StructureType*>(type2.data());
     QVERIFY(sType2);
     QCOMPARE(sType2->toString(), QString("B"));
     Declaration* decl2 = sType2->declaration(top);
     QVERIFY(decl2);
 
     TopDUContext* top2 = dynamic_cast<TopDUContext*>(top->importedParentContexts()[0].context(top));
     QVERIFY(top2);
     QCOMPARE(top2->localDeclarations().size(), 2);
     QCOMPARE(top2->localDeclarations()[0], decl);
     QCOMPARE(top2->localDeclarations()[1], decl2);
     qDebug() << "DECL RANGE:" << top2->localDeclarations()[0]->range().castToSimpleRange();
     qDebug() << "CTX RANGE:" << top2->localDeclarations()[0]->internalContext()->range().castToSimpleRange();
 
     // validate uses:
     QCOMPARE(top->usesCount(), 14);
     QCOMPARE(top->uses()[0].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A"));
     QCOMPARE(top->uses()[1].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A"));
     QCOMPARE(top->uses()[2].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A::Q"));
     QCOMPARE(top->uses()[3].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B"));
     QCOMPARE(top->uses()[4].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B"));
     QCOMPARE(top->uses()[5].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B::Q"));
     QCOMPARE(top->uses()[6].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("a"));
     QCOMPARE(top->uses()[7].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A::m"));
     QCOMPARE(top->uses()[8].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("aq"));
     QCOMPARE(top->uses()[9].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("A::Q::m"));
     QCOMPARE(top->uses()[10].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("b"));
     QCOMPARE(top->uses()[11].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B::m"));
     QCOMPARE(top->uses()[12].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("bq"));
     QCOMPARE(top->uses()[13].usedDeclaration(top)->qualifiedIdentifier(), QualifiedIdentifier("B::Q::m"));
 }
 
 void TestDUChain::testHeaderParsingOrder1()
 {
     TestFile header(QStringLiteral("typedef const A<int> B;\n"), QStringLiteral("h"));
     TestFile impl("template<class T> class A{};\n"
                   "#include \"" + header.url().str() + "\"\n"
                   "B c;", QStringLiteral("cpp"), &header);
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(impl.waitForParsed(500000));
 
     DUChainReadLocker lock;
     TopDUContext* top = impl.topContext().data();
     QVERIFY(top);
     QCOMPARE(top->localDeclarations().size(), 2);
     QCOMPARE(top->importedParentContexts().size(), 1);
     AbstractType::Ptr type = top->localDeclarations()[1]->abstractType();
     TypeAliasType* aType = dynamic_cast<TypeAliasType*>(type.data());
     QVERIFY(aType);
     AbstractType::Ptr targetType = aType->type();
     QVERIFY(targetType);
     IdentifiedType *idType = dynamic_cast<IdentifiedType*>(targetType.data());
     QVERIFY(idType);
     // this declaration could be resolved, because it was created with an
     // indirect DeclarationId that is resolved from the perspective of 'top'
     Declaration* decl = idType->declaration(top);
     // NOTE: the decl. doesn't know (yet) about the template insantiation <int>
     QVERIFY(decl);
     QCOMPARE(decl, top->localDeclarations()[0]);
 
     // now ensure that a use was build for 'A' in header1
     TopDUContext* top2 = dynamic_cast<TopDUContext*>(top->importedParentContexts()[0].context(top));
     QVERIFY(top2);
     QEXPECT_FAIL("", "the use could not be created because the corresponding declaration didn't exist yet", Continue);
     QCOMPARE(top2->usesCount(), 1);
     // Declaration* decl2 = top2->uses()[0].usedDeclaration(top2);
     // QVERIFY(decl2);
     // QCOMPARE(decl, decl2);
 }
 
 void TestDUChain::testHeaderParsingOrder2()
 {
     TestFile header(QStringLiteral("template<class T> class A{};\n"), QStringLiteral("h"));
     TestFile header2(QStringLiteral("typedef const A<int> B;\n"), QStringLiteral("h"));
     TestFile impl("#include \"" + header.url().str() + "\"\n"
                   "#include \"" + header2.url().str() + "\"\n"
                   "B c;", QStringLiteral("cpp"), &header);
 
     impl.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(impl.waitForParsed(500000));
 
     DUChainReadLocker lock;
     TopDUContext* top = impl.topContext().data();
     QVERIFY(top);
     QCOMPARE(top->localDeclarations().size(), 1);
     QCOMPARE(top->importedParentContexts().size(), 2);
     AbstractType::Ptr type = top->localDeclarations()[0]->abstractType();
     TypeAliasType* aType = dynamic_cast<TypeAliasType*>(type.data());
     QVERIFY(aType);
     AbstractType::Ptr targetType = aType->type();
     QVERIFY(targetType);
     IdentifiedType *idType = dynamic_cast<IdentifiedType*>(targetType.data());
     QVERIFY(idType);
     Declaration* decl = idType->declaration(top);
     // NOTE: the decl. doesn't know (yet) about the template insantiation <int>
     QVERIFY(decl);
 
     // now ensure that a use was build for 'A' in header2
     TopDUContext* top2 = dynamic_cast<TopDUContext*>(top->importedParentContexts()[1].context(top));
     QVERIFY(top2);
     QCOMPARE(top2->usesCount(), 1);
     Declaration* decl2 = top2->uses()[0].usedDeclaration(top2);
     QCOMPARE(decl, decl2);
 }
 
 void TestDUChain::testMacrosRanges()
 {
     TestFile file(QStringLiteral("#define FUNC_MACROS(x) struct str##x{};\nFUNC_MACROS(x);"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto macroDefinition = file.topContext()->localDeclarations()[0];
     QVERIFY(macroDefinition);
     QCOMPARE(macroDefinition->range(), RangeInRevision(0,8,0,19));
     auto structDeclaration = file.topContext()->localDeclarations()[1];
     QVERIFY(structDeclaration);
     QCOMPARE(structDeclaration->range(), RangeInRevision(1,0,1,0));
 
     QCOMPARE(macroDefinition->uses().size(), 1);
     QCOMPARE(macroDefinition->uses().begin()->first(), RangeInRevision(1,0,1,11));
 }
 
 void TestDUChain::testMacroUses()
 {
     TestFile file(QStringLiteral("#define USER(x) x\n#define USED\nUSER(USED)"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto macroDefinition1 = file.topContext()->localDeclarations()[0];
     auto macroDefinition2 = file.topContext()->localDeclarations()[1];
 
     QCOMPARE(macroDefinition1->uses().size(), 1);
     QCOMPARE(macroDefinition1->uses().begin()->first(), RangeInRevision(2,0,2,4));
 #if CINDEX_VERSION_MINOR < 32
     QEXPECT_FAIL("", "This appears to be a clang bug, the AST doesn't contain the macro use", Continue);
 #endif
     QCOMPARE(macroDefinition2->uses().size(), 1);
     if (macroDefinition2->uses().size())
     {
         QCOMPARE(macroDefinition2->uses().begin()->first(), RangeInRevision(2,5,2,9));
     }
 }
 
 void TestDUChain::testMultiLineMacroRanges()
 {
     TestFile file(QStringLiteral("#define FUNC_MACROS(x) struct str##x{};\nFUNC_MACROS(x\n);"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto macroDefinition = file.topContext()->localDeclarations()[0];
     QVERIFY(macroDefinition);
     QCOMPARE(macroDefinition->range(), RangeInRevision(0,8,0,19));
     auto structDeclaration = file.topContext()->localDeclarations()[1];
     QVERIFY(structDeclaration);
     QCOMPARE(structDeclaration->range(), RangeInRevision(1,0,1,0));
 
     QCOMPARE(macroDefinition->uses().size(), 1);
     QCOMPARE(macroDefinition->uses().begin()->first(), RangeInRevision(1,0,1,11));
 }
 
 void TestDUChain::testNestedMacroRanges()
 {
     TestFile file(QStringLiteral("#define INNER int var; var = 0;\n#define MACRO() INNER\nint main(){MACRO(\n);}"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 3);
     auto main = file.topContext()->localDeclarations()[2];
     QVERIFY(main);
     auto mainCtx = main->internalContext()->childContexts().first();
     QVERIFY(mainCtx);
     QCOMPARE(mainCtx->localDeclarations().size(), 1);
     auto var = mainCtx->localDeclarations().first();
     QVERIFY(var);
     QCOMPARE(var->range(), RangeInRevision(2,11,2,11));
 
     QCOMPARE(var->uses().size(), 1);
     QCOMPARE(var->uses().begin()->first(), RangeInRevision(2,11,2,11));
 }
 
 void TestDUChain::testNestedImports()
 {
     TestFile B(QStringLiteral("#pragma once\nint B();\n"), QStringLiteral("h"));
     TestFile C("#pragma once\n#include \"" + B.url().str() + "\"\nint C();\n", QStringLiteral("h"));
     TestFile A("#include \"" + B.url().str() + "\"\n" + "#include \"" + C.url().str() + "\"\nint A();\n", QStringLiteral("cpp"));
 
     A.parse();
     QVERIFY(A.waitForParsed(5000));
 
     DUChainReadLocker lock;
 
     auto BCtx = DUChain::self()->chainForDocument(B.url().toUrl());
     QVERIFY(BCtx);
     QVERIFY(BCtx->importedParentContexts().isEmpty());
 
     auto CCtx = DUChain::self()->chainForDocument(C.url().toUrl());
     QVERIFY(CCtx);
     QCOMPARE(CCtx->importedParentContexts().size(), 1);
     QVERIFY(CCtx->imports(BCtx, CursorInRevision(1, 10)));
 
     auto ACtx = A.topContext();
     QVERIFY(ACtx);
     QCOMPARE(ACtx->importedParentContexts().size(), 2);
     QVERIFY(ACtx->imports(BCtx, CursorInRevision(0, 10)));
     QVERIFY(ACtx->imports(CCtx, CursorInRevision(1, 10)));
 }
 
 void TestDUChain::testEnvironmentWithDifferentOrderOfElements()
 {
     TestFile file(QStringLiteral("int main();\n"), QStringLiteral("cpp"));
 
     m_provider->includes.clear();
     m_provider->includes.append(Path(QStringLiteral("/path1")));
     m_provider->includes.append(Path(QStringLiteral("/path2")));
 
     m_provider->defines.clear();
     m_provider->defines.insert(QStringLiteral("key1"), QStringLiteral("value1"));
     m_provider->defines.insert(QStringLiteral("key2"), QStringLiteral("value2"));
     m_provider->defines.insert(QStringLiteral("key3"), QStringLiteral("value3"));
 
     uint previousHash = 0;
     for (int i: {0, 1, 2, 3}) {
         file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
 
         QVERIFY(file.waitForParsed(5000));
 
         {
             DUChainReadLocker lock;
             QVERIFY(file.topContext());
             auto env = dynamic_cast<ClangParsingEnvironmentFile*>(file.topContext()->parsingEnvironmentFile().data());
             QVERIFY(env);
             QCOMPARE(env->environmentQuality(), ClangParsingEnvironment::Source);
             if (previousHash) {
                 if (i == 3) {
                     QVERIFY(previousHash != env->environmentHash());
                 } else {
                     QCOMPARE(previousHash, env->environmentHash());
                 }
             }
             previousHash = env->environmentHash();
             QVERIFY(previousHash);
         }
 
         if (i == 0) {
             //Change order of defines. Hash of the environment should stay the same.
             m_provider->defines.clear();
             m_provider->defines.insert(QStringLiteral("key3"), QStringLiteral("value3"));
             m_provider->defines.insert(QStringLiteral("key1"), QStringLiteral("value1"));
             m_provider->defines.insert(QStringLiteral("key2"), QStringLiteral("value2"));
         } else if (i == 1) {
             //Add the same macros twice. Hash of the environment should stay the same.
             m_provider->defines.clear();
             m_provider->defines.insert(QStringLiteral("key2"), QStringLiteral("value2"));
             m_provider->defines.insert(QStringLiteral("key3"), QStringLiteral("value3"));
             m_provider->defines.insert(QStringLiteral("key3"), QStringLiteral("value3"));
             m_provider->defines.insert(QStringLiteral("key1"), QStringLiteral("value1"));
         } else if (i == 2) {
             //OTOH order of includes should change hash of the environment.
             m_provider->includes.clear();
             m_provider->includes.append(Path(QStringLiteral("/path2")));
             m_provider->includes.append(Path(QStringLiteral("/path1")));
         }
     }
 }
 
 void TestDUChain::testReparseMacro()
 {
     TestFile file(QStringLiteral("#define DECLARE(a) typedef struct a##_ {} *a;\nDECLARE(D);\nD d;"), QStringLiteral("cpp"));
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST));
     QVERIFY(file.waitForParsed(5000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
     }
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 5);
 
     auto macroDefinition = file.topContext()->localDeclarations()[0];
     QVERIFY(macroDefinition);
     QCOMPARE(macroDefinition->range(), RangeInRevision(0,8,0,15));
     QCOMPARE(macroDefinition->uses().size(), 1);
     QCOMPARE(macroDefinition->uses().begin()->first(), RangeInRevision(1,0,1,7));
 
     auto structDeclaration = file.topContext()->localDeclarations()[1];
     QVERIFY(structDeclaration);
     QCOMPARE(structDeclaration->range(), RangeInRevision(1,0,1,0));
 
     auto structTypedef = file.topContext()->localDeclarations()[3];
     QVERIFY(structTypedef);
     QCOMPARE(structTypedef->range(), RangeInRevision(1,8,1,9));
     QCOMPARE(structTypedef->uses().size(), 1);
     QCOMPARE(structTypedef->uses().begin()->first(), RangeInRevision(2,0,2,1));
 }
 
 void TestDUChain::testGotoStatement()
 {
     TestFile file(QStringLiteral("int main() {\ngoto label;\ngoto label;\nlabel: return 0;}"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 1);
     auto main = file.topContext()->localDeclarations()[0];
     QVERIFY(main);
     auto mainCtx = main->internalContext()->childContexts().first();
     QVERIFY(mainCtx);
     QCOMPARE(mainCtx->localDeclarations().size(), 1);
     auto label = mainCtx->localDeclarations().first();
     QVERIFY(label);
     QCOMPARE(label->range(), RangeInRevision(3,0,3,5));
 
     QCOMPARE(label->uses().size(), 1);
     QCOMPARE(label->uses().begin()->first(), RangeInRevision(1,5,1,10));
     QCOMPARE(label->uses().begin()->last(), RangeInRevision(2,5,2,10));
 }
 
 void TestDUChain::testRangesOfOperatorsInsideMacro()
 {
     TestFile file(QStringLiteral("class Test{public: Test& operator++(int);};\n#define MACRO(var) var++;\nint main(){\nTest tst; MACRO(tst)}"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 3);
     auto testClass = file.topContext()->localDeclarations()[0];
     QVERIFY(testClass);
     auto operatorPlusPlus = testClass->internalContext()->localDeclarations().first();
     QVERIFY(operatorPlusPlus);
     QCOMPARE(operatorPlusPlus->uses().size(), 1);
     QCOMPARE(operatorPlusPlus->uses().begin()->first(), RangeInRevision(3,10,3,10));
 }
 
 void TestDUChain::testUsesCreatedForDeclarations()
 {
     auto code = R"(template<typename T> void functionTemplate(T);
             template<typename U> void functionTemplate(U) {}
 
             namespace NS { class Class{}; }
             using NS::Class;
 
             Class function();
             NS::Class function() { return {}; }
 
             int main () {
                 functionTemplate(int());
                 function(); }
     )";
     TestFile file(code, QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
 
     auto functionTemplate = file.topContext()->findDeclarations(QualifiedIdentifier(QStringLiteral("functionTemplate")));
     QVERIFY(!functionTemplate.isEmpty());
     auto functionTemplateDeclaration = DUChainUtils::declarationForDefinition(functionTemplate.first());
     QVERIFY(!functionTemplateDeclaration->isDefinition());
 #if CINDEX_VERSION_MINOR < 29
     QEXPECT_FAIL("", "No API in LibClang to determine function template type", Continue);
 #endif
     QCOMPARE(functionTemplateDeclaration->uses().count(), 1);
 
     auto function = file.topContext()->findDeclarations(QualifiedIdentifier(QStringLiteral("function")));
     QVERIFY(!function.isEmpty());
     auto functionDeclaration = DUChainUtils::declarationForDefinition(function.first());
     QVERIFY(!functionDeclaration->isDefinition());
     QCOMPARE(functionDeclaration->uses().count(), 1);
 }
 
 void TestDUChain::testReparseIncludeGuard()
 {
     TestFile header(QStringLiteral("#ifndef GUARD\n#define GUARD\nint something;\n#endif\n"), QStringLiteral("h"));
     TestFile impl("#include \"" + header.url().str() + "\"\n", QStringLiteral("cpp"), &header);
 
     QVERIFY(impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::AST  )));
     {
         DUChainReadLocker lock;
         QCOMPARE(static_cast<TopDUContext*>(impl.topContext()->
             importedParentContexts().first().context(impl.topContext()))->problems().size(), 0);
     }
     QVERIFY(impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive)));
     {
         DUChainReadLocker lock;
         QCOMPARE(static_cast<TopDUContext*>(impl.topContext()->
             importedParentContexts().first().context(impl.topContext()))->problems().size(), 0);
     }
 }
 
 void TestDUChain::testExternC()
 {
     auto code = R"(extern "C" { void foo(); })";
     TestFile file(code, QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
     QVERIFY(file.waitForParsed());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     QVERIFY(!top->findDeclarations(QualifiedIdentifier("foo")).isEmpty());
 }
 
 void TestDUChain::testReparseUnchanged_data()
 {
     QTest::addColumn<QString>("headerCode");
     QTest::addColumn<QString>("implCode");
 
     QTest::newRow("include-guards") << R"(
         #ifndef GUARD
         #define GUARD
         int something;
         #endif
     )" << R"(
         #include "%1"
     )";
 
     QTest::newRow("template-default-parameters") << R"(
         #ifndef TEST_H
         #define TEST_H
 
         template<unsigned T=123, unsigned... U>
         class dummy;
 
         template<unsigned T, unsigned... U>
         class dummy {
             int field[T];
         };
 
         #endif
     )" << R"(
         #include "%1"
 
         int main(int, char **) {
             dummy<> x;
             (void)x;
         }
     )";
 }
 
 void TestDUChain::testReparseUnchanged()
 {
     QFETCH(QString, headerCode);
     QFETCH(QString, implCode);
     TestFile header(headerCode, QStringLiteral("h"));
     TestFile impl(implCode.arg(header.url().str()), QStringLiteral("cpp"), &header);
 
     auto checkProblems = [&] (bool reparsed) {
         DUChainReadLocker lock;
         auto headerCtx = DUChain::self()->chainForDocument(header.url());
         QVERIFY(headerCtx);
         QVERIFY(headerCtx->problems().isEmpty());
         auto implCtx = DUChain::self()->chainForDocument(impl.url());
         QVERIFY(implCtx);
         if (reparsed && CINDEX_VERSION_MINOR > 29 && CINDEX_VERSION_MINOR < 33) {
             QEXPECT_FAIL("template-default-parameters", "the precompiled preamble messes the default template parameters up in clang 3.7", Continue);
         }
         QVERIFY(implCtx->problems().isEmpty());
     };
 
     impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::AST  ));
     checkProblems(false);
 
     impl.parseAndWait(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses | TopDUContext::ForceUpdateRecursive));
     checkProblems(true);
 }
 
 void TestDUChain::testTypeAliasTemplate()
 {
     TestFile file(QStringLiteral("template <typename T> using Alias = T; using Foo = Alias<int>;"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
 
     QCOMPARE(file.topContext()->localDeclarations().size(), 2);
     auto templateAlias = file.topContext()->localDeclarations().first();
     QVERIFY(templateAlias);
 #if CINDEX_VERSION_MINOR < 31
     QEXPECT_FAIL("", "TypeAliasTemplate is not exposed via LibClang", Abort);
 #endif
     QVERIFY(templateAlias->isTypeAlias());
     QVERIFY(templateAlias->abstractType());
     QCOMPARE(templateAlias->abstractType()->toString(), QStringLiteral("Alias"));
     QCOMPARE(templateAlias->uses().size(), 1);
     QCOMPARE(templateAlias->uses().first().size(), 1);
     QCOMPARE(templateAlias->uses().first().first(), RangeInRevision(0, 51, 0, 56));
 }
 
 void TestDUChain::testDeclarationsInsideMacroExpansion()
 {
     TestFile header(QStringLiteral("#define DECLARE(a) typedef struct a##__ {int var;} *a\nDECLARE(D);\n"), QStringLiteral("h"));
     TestFile file("#include \"" + header.url().str() + "\"\nint main(){\nD d; d->var;}\n", QStringLiteral("cpp"));
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST));
     QVERIFY(file.waitForParsed(5000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
     }
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST|TopDUContext::ForceUpdate));
     QVERIFY(file.waitForParsed(5000));
 
     DUChainReadLocker lock;
     QVERIFY(file.topContext());
     QCOMPARE(file.topContext()->localDeclarations().size(), 1);
 
     auto context = file.topContext()->childContexts().first()->childContexts().first();
     QVERIFY(context);
     QCOMPARE(context->localDeclarations().size(), 1);
     QCOMPARE(context->usesCount(), 3);
 
     QCOMPARE(context->uses()[0].m_range, RangeInRevision({2, 0}, {2, 1}));
     QCOMPARE(context->uses()[1].m_range, RangeInRevision({2, 5}, {2, 6}));
     QCOMPARE(context->uses()[2].m_range, RangeInRevision({2, 8}, {2, 11}));
 }
 
 // see also: https://bugs.kde.org/show_bug.cgi?id=368067
 void TestDUChain::testForwardTemplateTypeParameterContext()
 {
     TestFile file(QStringLiteral(R"(
         template<typename MatchingName> class Foo;
 
         class MatchingName { void bar(); };
         void MatchingName::bar() {  }
     )"), QStringLiteral("cpp"));
 
     file.parse();
     QVERIFY(file.waitForParsed(500));
     DUChainReadLocker lock;
     const auto top = file.topContext();
     QVERIFY(top);
     DUChainDumper dumper(DUChainDumper::Features(DUChainDumper::DumpContext | DUChainDumper::DumpProblems));
     dumper.dump(top);
 
     auto declarations = top->localDeclarations();
     QCOMPARE(declarations.size(), 2);
 }
 
 // see also: https://bugs.kde.org/show_bug.cgi?id=368460
 void TestDUChain::testTemplateFunctionParameterName()
 {
     TestFile file(QStringLiteral(R"(
         template<class T>
         void foo(int name);
 
         void bar(int name);
     )"), QStringLiteral("cpp"));
 
     file.parse();
     QVERIFY(file.waitForParsed(500));
     DUChainReadLocker lock;
     const auto top = file.topContext();
     QVERIFY(top);
     DUChainDumper dumper(DUChainDumper::Features(DUChainDumper::DumpContext | DUChainDumper::DumpProblems));
     dumper.dump(top);
 
     auto declarations = top->localDeclarations();
     QCOMPARE(declarations.size(), 2);
 
     for (auto decl : declarations) {
-        auto ctx = DUChainUtils::getArgumentContext(decl);
+        auto ctx = DUChainUtils::argumentContext(decl);
         QVERIFY(ctx);
         auto args = ctx->localDeclarations();
         if (decl == declarations.first())
             QEXPECT_FAIL("", "We get two declarations, for both template and args :(", Continue);
         QCOMPARE(args.size(), 1);
         if (decl == declarations.first())
             QEXPECT_FAIL("", "see above, this then triggers T T here", Continue);
         QCOMPARE(args.first()->toString(), QStringLiteral("int name"));
     }
 }
 
 static bool containsErrors(const QList<Problem::Ptr>& problems)
 {
     auto it = std::find_if(problems.begin(), problems.end(), [] (const Problem::Ptr& problem) {
         return problem->severity() == Problem::Error;
     });
     return it != problems.end();
 }
 
 static bool expectedXmmintrinErrors(const QList<Problem::Ptr>& problems)
 {
     for (const auto& problem : problems) {
         if (problem->severity() == Problem::Error && !problem->description().contains(QLatin1String("Cannot initialize a parameter of type"))) {
             return false;
         }
     }
     return true;
 }
 
 static void verifyNoErrors(TopDUContext* top, QSet<TopDUContext*>& checked)
 {
     const auto problems = top->problems();
     if (containsErrors(problems)) {
         qDebug() << top->url() << top->problems();
         if (top->url().str().endsWith(QLatin1String("xmmintrin.h")) && expectedXmmintrinErrors(problems)) {
             QEXPECT_FAIL("", "there are still some errors in xmmintrin.h b/c some clang provided intrinsincs are more strict than the GCC ones.", Continue);
             QVERIFY(false);
         } else {
             QFAIL("parse error detected");
         }
     }
     const auto imports = top->importedParentContexts();
     for (const auto& import : imports) {
         auto ctx = import.context(top);
         QVERIFY(ctx);
         auto importedTop = ctx->topContext();
         if (checked.contains(importedTop)) {
             continue;
         }
         checked.insert(importedTop);
         verifyNoErrors(importedTop, checked);
     }
 }
 
 void TestDUChain::testFriendDeclaration()
 {
     TestFile file(QStringLiteral(R"(
         struct FriendFoo
         {
             friend class FriendBar;
         };
 
         class FriendBar{};
 
         FriendBar friendBar;
     )"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(1000));
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->localDeclarations().size(), 3);
 
         auto friendBar = file.topContext()->localDeclarations()[1];
         if (CINDEX_VERSION_MINOR < 37) {
             QEXPECT_FAIL("", "Your clang version is too old", Abort);
         }
         QCOMPARE(friendBar->uses().size(), 1);
         QCOMPARE(friendBar->uses().begin()->first(), RangeInRevision(3,25,3,34));
         QCOMPARE(friendBar->uses().begin()->last(), RangeInRevision(8,8,8,17));
     }
 }
 
 void TestDUChain::testVariadicTemplateArguments()
 {
     TestFile file(QStringLiteral(R"(
         template<typename T, typename... Targs>
         class VariadicTemplate {};
 
         VariadicTemplate<int, double, bool> variadic;
     )"), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(1000));
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->localDeclarations().size(), 2);
 
         auto decl = file.topContext()->localDeclarations()[1];
         QVERIFY(decl);
         if (CINDEX_VERSION_MINOR < 37) {
             QEXPECT_FAIL("", "Your clang version is too old", Abort);
         }
         QCOMPARE(decl->toString(), QStringLiteral("VariadicTemplate< int, double, bool > variadic"));
 
         QVERIFY(decl->abstractType());
         QCOMPARE(decl->abstractType()->toString(), QStringLiteral("VariadicTemplate< int, double, bool >"));
     }
 }
 
 void TestDUChain::testGccCompatibility()
 {
     // TODO: make it easier to change the compiler provider for testing purposes
     QTemporaryDir dir;
     auto project = new TestProject(Path(dir.path()), this);
     auto definesAndIncludesConfig = project->projectConfiguration()->group("CustomDefinesAndIncludes");
     auto pathConfig = definesAndIncludesConfig.group("ProjectPath0");
     pathConfig.writeEntry("Path", ".");
     pathConfig.group("Compiler").writeEntry("Name", "GCC");
     m_projectController->addProject(project);
 
     {
         // TODO: Also test in C mode. Currently it doesn't work (some intrinsics missing?)
         TestFile file(QStringLiteral(R"(
             #include <x86intrin.h>
 
             int main() { return 0; }
         )"), QStringLiteral("cpp"), project, dir.path());
 
         file.parse();
         QVERIFY(file.waitForParsed(5000));
 
         DUChainReadLocker lock;
         QSet<TopDUContext*> checked;
         verifyNoErrors(file.topContext(), checked);
     }
 
     m_projectController->closeAllProjects();
 }
 
 void TestDUChain::testLambda()
 {
     TestFile file(QStringLiteral("auto lambda = [](int p1, int p2, int p3) { int var1, var2; };"), QStringLiteral("cpp"));
     QVERIFY(file.parseAndWait());
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
         QCOMPARE(file.topContext()->localDeclarations().size(), 1);
         QCOMPARE(file.topContext()->childContexts().size(), 1);
 
         auto lambdaContext = file.topContext()->childContexts().first();
 
         QCOMPARE(lambdaContext->type(), DUContext::Function);
 
         QCOMPARE(lambdaContext->localDeclarations().size(), 3);
         QCOMPARE(lambdaContext->childContexts().size(), 1);
         QCOMPARE(lambdaContext->childContexts().first()->type(), DUContext::Other);
         QCOMPARE(lambdaContext->childContexts().first()->localDeclarations().size(), 2);
     }
 }
 
 void TestDUChain::testQtIntegration()
 {
     QTemporaryDir includeDir;
     {
         QDir dir(includeDir.path());
         dir.mkdir(QStringLiteral("QtCore"));
         // create the file but don't put anything in it
         QFile header(includeDir.path() + "/QtCore/qobjectdefs.h");
         QVERIFY(header.open(QIODevice::WriteOnly | QIODevice::Text));
     }
     QTemporaryDir dir;
     auto project = new TestProject(Path(dir.path()), this);
     m_provider->defines.clear();
     m_provider->includes = {Path(includeDir.path() + "/QtCore")};
 
     m_projectController->addProject(project);
 
     {
         TestFile file(QStringLiteral(R"(
             #define slots
             #define signals
             #define Q_SLOTS
             #define Q_SIGNALS
             #include <QtCore/qobjectdefs.h>
 
             struct MyObject {
             public:
               void other1();
             public slots:
               void slot1();
             signals:
               void signal1();
             private Q_SLOTS:
               void slot2();
             Q_SIGNALS:
               void signal2();
             public:
               void other2();
             };
         )"), QStringLiteral("cpp"), project, dir.path());
 
         file.parse();
         QVERIFY(file.waitForParsed(5000));
 
         DUChainReadLocker lock;
         auto top = file.topContext();
         QVERIFY(top);
         QVERIFY(top->problems().isEmpty());
         const auto methods = top->childContexts().last()->localDeclarations();
         QCOMPARE(methods.size(), 6);
         for (auto method : methods) {
             auto classFunction = dynamic_cast<ClassFunctionDeclaration*>(method);
             QVERIFY(classFunction);
             auto id = classFunction->identifier().toString();
             QCOMPARE(classFunction->isSignal(), id.startsWith(QLatin1String("signal")));
             QCOMPARE(classFunction->isSlot(), id.startsWith(QLatin1String("slot")));
         }
     }
 
     m_projectController->closeAllProjects();
 }
 
 void TestDUChain::testHasInclude()
 {
     TestFile header(QStringLiteral(R"(
         #pragma once
         #if __has_include_next(<atomic>)
         // good
         #else
         #error broken c++11 setup (__has_include_next)
         #endif
     )"), QStringLiteral("h"));
     // NOTE: header is _not_ explicitly being parsed, instead the impl job does that
 
     TestFile file(QStringLiteral(R"(
         #if __has_include(<atomic>)
         // good
         #else
         #error broken c++11 setup (__has_include)
         #endif
         #include "%1"
     )").arg(header.url().str()), QStringLiteral("cpp"));
     file.parse(TopDUContext::AllDeclarationsContextsAndUses);
 
     QVERIFY(file.waitForParsed(1000));
     {
         DUChainDumper dumper{DUChainDumper::DumpProblems};
 
         DUChainReadLocker lock;
 
         QVERIFY(file.topContext());
         dumper.dump(file.topContext());
         QVERIFY(file.topContext()->problems().isEmpty());
 
         auto headerCtx = DUChain::self()->chainForDocument(header.url());
         QVERIFY(headerCtx);
         dumper.dump(headerCtx);
         QVERIFY(headerCtx->problems().count() <= 1);
         const auto& headerProblems = headerCtx->problems();
         for (const auto& problem : headerProblems) {
             // ignore the following error:  "#include_next with absolute path [-Winclude-next-absolute-path]" "" [ (2, 12)  ->  (2, 30) ]
             QVERIFY(problem->description().contains(QLatin1String("-Winclude-next-absolute-path")));
         }
     }
 }
diff --git a/plugins/classbrowser/classtree.cpp b/plugins/classbrowser/classtree.cpp
index ecb029462a..c5805a0c80 100644
--- a/plugins/classbrowser/classtree.cpp
+++ b/plugins/classbrowser/classtree.cpp
@@ -1,164 +1,164 @@
 /*
  * KDevelop Class viewer
  *
  * Copyright 2006 Adam Treat <treat@kde.org>
  * Copyright (c) 2006-2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2009 Lior Mualem <lior.m.kde@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "classtree.h"
 
 #include <QMenu>
 #include <QHeaderView>
 #include <QContextMenuEvent>
 #include <QScrollBar>
 
 #include "interfaces/contextmenuextension.h"
 #include "interfaces/icore.h"
 #include "interfaces/idocument.h"
 #include "interfaces/iplugincontroller.h"
 
 #include "language/interfaces/codecontext.h"
 
 #include "language/duchain/duchainbase.h"
 #include "language/duchain/duchain.h"
 #include "language/duchain/duchainlock.h"
 #include "language/duchain/declaration.h"
 
 #include "language/classmodel/classmodel.h"
 #include "classbrowserplugin.h"
 
 using namespace KDevelop;
 
 ClassTree::ClassTree( QWidget* parent, ClassBrowserPlugin* plugin )
   : QTreeView( parent )
   , m_plugin( plugin ), m_tooltip( nullptr )
 {
   header()->hide();
 
   setIndentation( 10 );
   setUniformRowHeights( true );
 
   connect( this, &ClassTree::activated, this, &ClassTree::itemActivated );
 }
 
 ClassTree::~ClassTree()
 {
 }
 
 static bool _populatingClassBrowserContextMenu = false;
 
 bool ClassTree::populatingClassBrowserContextMenu()
 {
   return _populatingClassBrowserContextMenu;
 }
 
 void ClassTree::contextMenuEvent( QContextMenuEvent* e )
 {
   QMenu *menu = new QMenu( this );
   QModelIndex index = indexAt( e->pos() );
   if ( index.isValid() )
   {
     Context* c;
     {
       DUChainReadLocker readLock( DUChain::lock() );
       if( Declaration* decl = dynamic_cast<Declaration*>( model()->duObjectForIndex( index ) ) )
         c = new DeclarationContext( decl );
       else
       {
         delete menu;
         return;
       }
     }
     _populatingClassBrowserContextMenu = true;
 
     QList<ContextMenuExtension> extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions(c, menu);
     ContextMenuExtension::populateMenu( menu, extensions );
 
     _populatingClassBrowserContextMenu = false;
   }
 
   if ( !menu->actions().isEmpty() )
     menu->exec(e->globalPos());
   delete menu;
 }
 
 bool ClassTree::event( QEvent* event )
 {
   if ( event->type() == QEvent::ToolTip )
   {
     // if we request a tooltip over a duobject item, show a tooltip for it
     QHelpEvent* helpEvent = static_cast<QHelpEvent*>(event);
     const QModelIndex idxView = indexAt(helpEvent->pos());
 
     DUChainReadLocker readLock( DUChain::lock() );
     if ( Declaration* decl = dynamic_cast<Declaration*>( model()->duObjectForIndex( idxView ) ) )
     {
       if ( m_tooltip ) {
         m_tooltip->close();
       }
       QWidget* navigationWidget = decl->topContext()->createNavigationWidget( decl );
       if ( navigationWidget )
       {
         m_tooltip = new KDevelop::NavigationToolTip(this, helpEvent->globalPos() + QPoint(40, 0), navigationWidget);
         m_tooltip->resize( navigationWidget->sizeHint() + QSize( 10, 10 ) );
         ActiveToolTip::showToolTip( m_tooltip );
         return true;
       }
     }
   }
 
   return QAbstractItemView::event( event );
 }
 
 ClassModel* ClassTree::model()
 {
   return static_cast<ClassModel*>( QTreeView::model() );
 }
 
 void ClassTree::itemActivated( const QModelIndex& index )
 {
   DUChainReadLocker readLock( DUChain::lock() );
 
   DeclarationPointer decl = DeclarationPointer( dynamic_cast<Declaration*>( model()->duObjectForIndex( index ) ) );
   readLock.unlock();
 
 // Delegate to plugin function
   m_plugin->showDefinition( decl );
 
   if( isExpanded( index ) )
     collapse( index );
   else
     expand( index );
 }
 
 void ClassTree::highlightIdentifier( const KDevelop::IndexedQualifiedIdentifier& a_id )
 {
-  QModelIndex index = model()->getIndexForIdentifier( a_id );
+  QModelIndex index = model()->indexForIdentifier( a_id );
   if ( !index.isValid() )
     return;
 
   // expand and select the item.
   selectionModel()->select( index, QItemSelectionModel::ClearAndSelect );
   scrollTo( index, PositionAtCenter );
   horizontalScrollBar()->setValue(horizontalScrollBar()->minimum());
   expand( index );
 }
 
 // kate: space-indent on; indent-width 2; tab-width: 4; replace-tabs on; auto-insert-doxygen on
 
diff --git a/plugins/contextbrowser/contextbrowser.cpp b/plugins/contextbrowser/contextbrowser.cpp
index ef1967e45a..eaef28dd3f 100644
--- a/plugins/contextbrowser/contextbrowser.cpp
+++ b/plugins/contextbrowser/contextbrowser.cpp
@@ -1,1500 +1,1500 @@
 /*
   * This file is part of KDevelop
  *
  * Copyright 2007 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "contextbrowser.h"
 
 #include "contextbrowserview.h"
 #include "browsemanager.h"
 #include "debug.h"
 
 #include <cstdlib>
 
 #include <QAction>
 #include <QDebug>
 #include <QLayout>
 #include <QMenu>
 #include <QTimer>
 #include <QToolButton>
 #include <QWidgetAction>
 
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include <KTextEditor/CodeCompletionInterface>
 #include <KTextEditor/Document>
 #include <KTextEditor/TextHintInterface>
 #include <KTextEditor/View>
 #include <KTextEditor/ConfigInterface>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iplugincontroller.h>
 
 #include <language/interfaces/codecontext.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <language/interfaces/iquickopen.h>
 
 #include <language/highlighting/colorcache.h>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/use.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/uses.h>
 #include <language/duchain/specializationstore.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <language/duchain/navigation/problemnavigationcontext.h>
 
 #include <language/util/navigationtooltip.h>
 
 #include <shell/problemmodel.h>
 #include <shell/problemmodelset.h>
 
 #include <util/texteditorhelpers.h>
 
 #include <sublime/mainwindow.h>
 
 using KTextEditor::Attribute;
 using KTextEditor::View;
 using namespace KDevelop;
 
 // Helper that follows the QObject::parent() chain, and returns the highest widget that has no parent.
 QWidget* masterWidget(QWidget* w)
 {
   while(w && w->parent() && qobject_cast<QWidget*>(w->parent()))
     w = qobject_cast<QWidget*>(w->parent());
   return w;
 }
 
 namespace {
 const unsigned int highlightingTimeout = 150;
 const float highlightingZDepth = -5000;
 const int maxHistoryLength = 30;
 
 // Helper that determines the context to use for highlighting at a specific position
 DUContext* contextForHighlightingAt(const KTextEditor::Cursor& position, TopDUContext* topContext)
 {
   DUContext* ctx = topContext->findContextAt(topContext->transformToLocalRevision(position));
   while(ctx && ctx->parentContext()
         && (ctx->type() == DUContext::Template || ctx->type() == DUContext::Helper
             || ctx->localScopeIdentifier().isEmpty()))
   {
     ctx = ctx->parentContext();
   }
   return ctx;
 }
 
 ///Duchain must be locked
 DUContext* contextAt(const QUrl& url, KTextEditor::Cursor cursor)
 {
   TopDUContext* topContext = DUChainUtils::standardContextForUrl(url);
   if (!topContext) return nullptr;
   return contextForHighlightingAt(KTextEditor::Cursor(cursor), topContext);
 }
 
 DeclarationPointer cursorDeclaration()
 {
   KTextEditor::View* view = ICore::self()->documentController()->activeTextDocumentView();
   if (!view) {
     return DeclarationPointer();
   }
 
   DUChainReadLocker lock;
 
   Declaration *decl = DUChainUtils::declarationForDefinition(DUChainUtils::itemUnderCursor(view->document()->url(), KTextEditor::Cursor(view->cursorPosition())).declaration);
   return DeclarationPointer(decl);
 }
 
 }
 
 class ContextBrowserViewFactory: public KDevelop::IToolViewFactory
 {
 public:
     explicit ContextBrowserViewFactory(ContextBrowserPlugin *plugin): m_plugin(plugin) {}
 
     QWidget* create(QWidget *parent = nullptr) override
     {
         ContextBrowserView* ret = new ContextBrowserView(m_plugin, parent);
         return ret;
     }
 
     Qt::DockWidgetArea defaultPosition() override
     {
         return Qt::BottomDockWidgetArea;
     }
 
     QString id() const override
     {
         return QStringLiteral("org.kdevelop.ContextBrowser");
     }
 
 private:
     ContextBrowserPlugin *m_plugin;
 };
 
 KXMLGUIClient* ContextBrowserPlugin::createGUIForMainWindow( Sublime::MainWindow* window )
 {
     m_browseManager = new BrowseManager(this);
 
     KXMLGUIClient* ret = KDevelop::IPlugin::createGUIForMainWindow(window);
 
     connect(ICore::self()->documentController(), &IDocumentController::documentJumpPerformed, this, &ContextBrowserPlugin::documentJumpPerformed);
 
     m_previousButton = new QToolButton();
     m_previousButton->setToolTip(i18n("Go back in context history"));
     m_previousButton->setAutoRaise(true);
     m_previousButton->setPopupMode(QToolButton::MenuButtonPopup);
     m_previousButton->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
     m_previousButton->setEnabled(false);
     m_previousButton->setFocusPolicy(Qt::NoFocus);
     m_previousMenu = new QMenu(m_previousButton);
     m_previousButton->setMenu(m_previousMenu);
     connect(m_previousButton.data(), &QToolButton::clicked, this, &ContextBrowserPlugin::historyPrevious);
     connect(m_previousMenu.data(), &QMenu::aboutToShow, this, &ContextBrowserPlugin::previousMenuAboutToShow);
 
     m_nextButton = new QToolButton();
     m_nextButton->setToolTip(i18n("Go forward in context history"));
     m_nextButton->setAutoRaise(true);
     m_nextButton->setPopupMode(QToolButton::MenuButtonPopup);
     m_nextButton->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
     m_nextButton->setEnabled(false);
     m_nextButton->setFocusPolicy(Qt::NoFocus);
     m_nextMenu = new QMenu(m_nextButton);
     m_nextButton->setMenu(m_nextMenu);
     connect(m_nextButton.data(), &QToolButton::clicked, this, &ContextBrowserPlugin::historyNext);
     connect(m_nextMenu.data(), &QMenu::aboutToShow, this, &ContextBrowserPlugin::nextMenuAboutToShow);
 
     IQuickOpen* quickOpen = KDevelop::ICore::self()->pluginController()->extensionForPlugin<IQuickOpen>(QStringLiteral("org.kdevelop.IQuickOpen"));
 
     if(quickOpen) {
       m_outlineLine = quickOpen->createQuickOpenLine(QStringList(), QStringList() << i18n("Outline"), IQuickOpen::Outline);
       m_outlineLine->setDefaultText(i18n("Outline..."));
       m_outlineLine->setToolTip(i18n("Navigate outline of active document, click to browse."));
     }
 
     connect(m_browseManager, &BrowseManager::startDelayedBrowsing,
             this, &ContextBrowserPlugin::startDelayedBrowsing);
     connect(m_browseManager, &BrowseManager::stopDelayedBrowsing,
             this, &ContextBrowserPlugin::stopDelayedBrowsing);
     connect(m_browseManager, &BrowseManager::invokeAction,
             this, &ContextBrowserPlugin::invokeAction);
 
     m_toolbarWidget = toolbarWidgetForMainWindow(window);
     m_toolbarWidgetLayout = new QHBoxLayout;
     m_toolbarWidgetLayout->setSizeConstraint(QLayout::SetMaximumSize);
     m_previousButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     m_nextButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     m_toolbarWidgetLayout->setMargin(0);
 
     m_toolbarWidgetLayout->addWidget(m_previousButton);
     if (m_outlineLine) {
       m_toolbarWidgetLayout->addWidget(m_outlineLine);
       m_outlineLine->setMaximumWidth(600);
       connect(ICore::self()->documentController(), &IDocumentController::documentClosed, m_outlineLine.data(), &IQuickOpenLine::clear);
     }
     m_toolbarWidgetLayout->addWidget(m_nextButton);
 
     if(m_toolbarWidget->children().isEmpty())
         m_toolbarWidget->setLayout(m_toolbarWidgetLayout);
 
     connect(ICore::self()->documentController(), &IDocumentController::documentActivated,
       this, &ContextBrowserPlugin::documentActivated);
 
     return ret;
 }
 
 void ContextBrowserPlugin::createActionsForMainWindow(Sublime::MainWindow* window, QString& xmlFile,
                                                       KActionCollection& actions)
 {
     xmlFile = QStringLiteral("kdevcontextbrowser.rc");
 
     QAction* sourceBrowseMode = actions.addAction(QStringLiteral("source_browse_mode"));
     sourceBrowseMode->setText( i18n("Source &Browse Mode") );
     sourceBrowseMode->setIcon( QIcon::fromTheme(QStringLiteral("arrow-up")) );
     sourceBrowseMode->setCheckable(true);
     connect(sourceBrowseMode, &QAction::triggered, m_browseManager, &BrowseManager::setBrowsing);
 
     QAction* previousContext = actions.addAction(QStringLiteral("previous_context"));
     previousContext->setText( i18n("&Previous Visited Context") );
     previousContext->setIcon( QIcon::fromTheme(QStringLiteral("go-previous-context") ) );
     actions.setDefaultShortcut( previousContext, Qt::META | Qt::Key_Left );
     QObject::connect(previousContext, &QAction::triggered, this, &ContextBrowserPlugin::previousContextShortcut);
 
     QAction* nextContext = actions.addAction(QStringLiteral("next_context"));
     nextContext->setText( i18n("&Next Visited Context") );
     nextContext->setIcon( QIcon::fromTheme(QStringLiteral("go-next-context") ) );
     actions.setDefaultShortcut( nextContext, Qt::META | Qt::Key_Right );
     QObject::connect(nextContext, &QAction::triggered, this, &ContextBrowserPlugin::nextContextShortcut);
 
     QAction* previousUse = actions.addAction(QStringLiteral("previous_use"));
     previousUse->setText( i18n("&Previous Use") );
     previousUse->setIcon( QIcon::fromTheme(QStringLiteral("go-previous-use")) );
     actions.setDefaultShortcut( previousUse, Qt::META | Qt::SHIFT |  Qt::Key_Left );
     QObject::connect(previousUse, &QAction::triggered, this, &ContextBrowserPlugin::previousUseShortcut);
 
     QAction* nextUse = actions.addAction(QStringLiteral("next_use"));
     nextUse->setText( i18n("&Next Use") );
     nextUse->setIcon( QIcon::fromTheme(QStringLiteral("go-next-use")) );
     actions.setDefaultShortcut( nextUse, Qt::META | Qt::SHIFT | Qt::Key_Right );
     QObject::connect(nextUse, &QAction::triggered, this, &ContextBrowserPlugin::nextUseShortcut);
 
     QWidgetAction* outline = new QWidgetAction(this);
     outline->setText(i18n("Context Browser"));
     QWidget* w = toolbarWidgetForMainWindow(window);
     w->setHidden(false);
     outline->setDefaultWidget(w);
     actions.addAction(QStringLiteral("outline_line"), outline);
     // Add to the actioncollection so one can set global shortcuts for the action
     actions.addAction(QStringLiteral("find_uses"), m_findUses);
 }
 
 void ContextBrowserPlugin::nextContextShortcut()
 {
   // TODO: cleanup
   historyNext();
 }
 
 void ContextBrowserPlugin::previousContextShortcut()
 {
   // TODO: cleanup
   historyPrevious();
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(ContextBrowserFactory, "kdevcontextbrowser.json", registerPlugin<ContextBrowserPlugin>();)
 
 ContextBrowserPlugin::ContextBrowserPlugin(QObject *parent, const QVariantList&)
     : KDevelop::IPlugin(QStringLiteral("kdevcontextbrowser"), parent)
     , m_viewFactory(new ContextBrowserViewFactory(this))
     , m_nextHistoryIndex(0)
     , m_textHintProvider(this)
 {
   qRegisterMetaType<KDevelop::IndexedDeclaration>("KDevelop::IndexedDeclaration");
 
   core()->uiController()->addToolView(i18n("Code Browser"), m_viewFactory);
 
   connect( core()->documentController(), &IDocumentController::textDocumentCreated, this, &ContextBrowserPlugin::textDocumentCreated );
   connect( DUChain::self(), &DUChain::updateReady, this, &ContextBrowserPlugin::updateReady);
   connect( ColorCache::self(), &ColorCache::colorsGotChanged, this, &ContextBrowserPlugin::colorSetupChanged );
 
   connect( DUChain::self(), &DUChain::declarationSelected,
            this, &ContextBrowserPlugin::declarationSelectedInUI );
 
   m_updateTimer = new QTimer(this);
   m_updateTimer->setSingleShot(true);
   connect( m_updateTimer, &QTimer::timeout, this, &ContextBrowserPlugin::updateViews );
 
   //Needed global action for the context-menu extensions
   m_findUses = new QAction(i18n("Find Uses"), this);
   connect(m_findUses, &QAction::triggered, this, &ContextBrowserPlugin::findUses);
 }
 
 ContextBrowserPlugin::~ContextBrowserPlugin()
 {
   ///TODO: QObject inheritance should suffice?
   delete m_nextMenu;
   delete m_previousMenu;
   delete m_toolbarWidgetLayout;
 
   delete m_previousButton;
   delete m_outlineLine;
   delete m_nextButton;
 }
 
 void ContextBrowserPlugin::unload()
 {
   core()->uiController()->removeToolView(m_viewFactory);
 }
 
 KDevelop::ContextMenuExtension ContextBrowserPlugin::contextMenuExtension(KDevelop::Context* context, QWidget* parent)
 {
   KDevelop::ContextMenuExtension menuExt = KDevelop::IPlugin::contextMenuExtension(context, parent);
 
   KDevelop::DeclarationContext *codeContext = dynamic_cast<KDevelop::DeclarationContext*>(context);
 
   if (!codeContext)
       return menuExt;
 
   DUChainReadLocker lock(DUChain::lock());
 
   if(!codeContext->declaration().data())
     return menuExt;
 
   menuExt.addAction(KDevelop::ContextMenuExtension::NavigationGroup, m_findUses);
 
   return menuExt;
 }
 
 void ContextBrowserPlugin::showUses(const DeclarationPointer& declaration)
 {
   QMetaObject::invokeMethod(this, "showUsesDelayed", Qt::QueuedConnection,
                             Q_ARG(KDevelop::DeclarationPointer, declaration));
 }
 
 void ContextBrowserPlugin::showUsesDelayed(const DeclarationPointer& declaration)
 {
   DUChainReadLocker lock;
 
   Declaration* decl = declaration.data();
   if(!decl) {
     return;
   }
   QWidget* toolView = ICore::self()->uiController()->findToolView(i18n("Code Browser"), m_viewFactory, KDevelop::IUiController::CreateAndRaise);
   if(!toolView) {
     return;
   }
   ContextBrowserView* view = dynamic_cast<ContextBrowserView*>(toolView);
   Q_ASSERT(view);
   view->allowLockedUpdate();
   view->setDeclaration(decl, decl->topContext(), true);
   //We may get deleted while the call to acceptLink, so make sure we don't crash in that case
   QPointer<AbstractNavigationWidget> widget = dynamic_cast<AbstractNavigationWidget*>(view->navigationWidget());
   if(widget && widget->context()) {
     auto nextContext = widget->context()->execute(
       NavigationAction(declaration, KDevelop::NavigationAction::ShowUses));
 
     if(widget) {
       widget->setContext( nextContext );
     }
   }
 }
 
 void ContextBrowserPlugin::findUses()
 {
   showUses(cursorDeclaration());
 }
 
 ContextBrowserHintProvider::ContextBrowserHintProvider(ContextBrowserPlugin* plugin)
   : m_plugin(plugin)
 {
 }
 
 QString ContextBrowserHintProvider::textHint(View* view, const KTextEditor::Cursor& cursor)
 {
   m_plugin->m_mouseHoverCursor = KTextEditor::Cursor(cursor);
   if(!view) {
     qCWarning(PLUGIN_CONTEXTBROWSER) << "could not cast to view";
   }else{
     m_plugin->m_mouseHoverDocument = view->document()->url();
     m_plugin->m_updateViews << view;
   }
   m_plugin->m_updateTimer->start(1); // triggers updateViews()
 
   m_plugin->showToolTip(view, cursor);
   return QString();
 }
 
 void ContextBrowserPlugin::stopDelayedBrowsing() {
   hideToolTip();
 }
 
 void ContextBrowserPlugin::invokeAction(int index)
 {
   if (!m_currentNavigationWidget)
     return;
 
 
   auto navigationWidget = qobject_cast<AbstractNavigationWidget*>(m_currentNavigationWidget);
   if (!navigationWidget)
     return;
 
   // TODO: Add API in AbstractNavigation{Widget,Context}?
   QMetaObject::invokeMethod(navigationWidget->context().data(), "executeAction", Q_ARG(int, index));
 }
 
 void ContextBrowserPlugin::startDelayedBrowsing(KTextEditor::View* view) {
   if(!m_currentToolTip) {
     showToolTip(view, view->cursorPosition());
   }
 }
 
 void ContextBrowserPlugin::hideToolTip() {
   if(m_currentToolTip) {
     m_currentToolTip->deleteLater();
     m_currentToolTip = nullptr;
     m_currentNavigationWidget = nullptr;
     m_currentToolTipProblems.clear();
     m_currentToolTipDeclaration = {};
   }
 }
 
 static QVector<KDevelop::IProblem::Ptr> findProblemsUnderCursor(TopDUContext* topContext, KTextEditor::Cursor position)
 {
   QVector<KDevelop::IProblem::Ptr> problems;
   const auto modelsData = ICore::self()->languageController()->problemModelSet()->models();
   for (const auto& modelData : modelsData) {
     foreach (const auto& problem, modelData.model->problems(topContext->url())) {
       DocumentRange problemRange = problem->finalLocation();
       if (problemRange.contains(position) || (problemRange.isEmpty() && problemRange.boundaryAtCursor(position)))
         problems += problem;
     }
   }
 
   return problems;
 }
 
 static QVector<KDevelop::IProblem::Ptr> findProblemsCloseToCursor(TopDUContext* topContext, KTextEditor::Cursor position, KTextEditor::View* view)
 {
   QVector<KDevelop::IProblem::Ptr> allProblems;
   const auto modelsData = ICore::self()->languageController()->problemModelSet()->models();
   for (const auto& modelData : modelsData) {
     const auto problems = modelData.model->problems(topContext->url());
     allProblems.reserve(allProblems.size() + problems.size());
     for (const auto& problem : problems) {
       allProblems += problem;
     }
   }
 
   if (allProblems.isEmpty())
     return allProblems;
 
   std::sort(allProblems.begin(), allProblems.end(),
             [position](const KDevelop::IProblem::Ptr& a, const KDevelop::IProblem::Ptr& b) {
     const auto aRange = a->finalLocation();
     const auto bRange = b->finalLocation();
 
     const auto aLineDistance = qMin(qAbs(aRange.start().line() - position.line()),
                                     qAbs(aRange.end().line() - position.line()));
     const auto bLineDistance = qMin(qAbs(bRange.start().line() - position.line()),
                                     qAbs(bRange.end().line() - position.line()));
     if (aLineDistance != bLineDistance) {
       return aLineDistance < bLineDistance;
     }
 
     if (aRange.start().line() == bRange.start().line()) {
       return qAbs(aRange.start().column() - position.column()) <
         qAbs(bRange.start().column() - position.column());
     }
     return qAbs(aRange.end().column() - position.column()) <
       qAbs(bRange.end().column() - position.column());
   });
 
   QVector<KDevelop::IProblem::Ptr> closestProblems;
 
   // Show problems, located on the same line
   foreach (auto problem, allProblems) {
     auto r = problem->finalLocation();
     if (r.onSingleLine() && r.start().line() == position.line())
       closestProblems += problem;
     else
       break;
   }
 
   // If not, only show it in case there's only whitespace
   // between the current cursor position and the problem line
   if (closestProblems.isEmpty()) {
     foreach (auto problem, allProblems) {
       auto r = problem->finalLocation();
 
       KTextEditor::Range dist;
       KTextEditor::Cursor bound(r.start().line(), 0);
       if (position < r.start())
         dist = KTextEditor::Range(position, bound);
       else {
         bound.setLine(r.end().line() + 1);
         dist = KTextEditor::Range(bound, position);
       }
 
       if (view->document()->text(dist).trimmed().isEmpty())
         closestProblems += problem;
       else
         break;
     }
   }
 
   return closestProblems;
 }
 
 QWidget* ContextBrowserPlugin::navigationWidgetForPosition(KTextEditor::View* view, KTextEditor::Cursor position)
 {
   QUrl viewUrl = view->document()->url();
   const auto languages = ICore::self()->languageController()->languagesForUrl(viewUrl);
 
   DUChainReadLocker lock(DUChain::lock());
   for (const auto language : languages) {
     auto widget = language->specialLanguageObjectNavigationWidget(viewUrl, KTextEditor::Cursor(position));
     auto navigationWidget = qobject_cast<AbstractNavigationWidget*>(widget);
     if(navigationWidget)
       return navigationWidget;
   }
 
   TopDUContext* topContext = DUChainUtils::standardContextForUrl(view->document()->url());
   if (topContext) {
     // first pass: find problems under the cursor
     const auto problems = findProblemsUnderCursor(topContext, position);
     if (!problems.isEmpty()) {
       if (problems == m_currentToolTipProblems && m_currentToolTip) {
         return nullptr;
       }
 
       m_currentToolTipProblems = problems;
       auto widget = new AbstractNavigationWidget;
       auto context = new ProblemNavigationContext(problems);
       context->setTopContext(TopDUContextPointer(topContext));
       widget->setContext(NavigationContextPointer(context));
       return widget;
     }
   }
 
   auto declUnderCursor = DUChainUtils::itemUnderCursor(viewUrl, position).declaration;
   Declaration* decl = DUChainUtils::declarationForDefinition(declUnderCursor);
   if (decl && decl->kind() == Declaration::Alias) {
     AliasDeclaration* alias = dynamic_cast<AliasDeclaration*>(decl);
     Q_ASSERT(alias);
     DUChainReadLocker lock;
     decl = alias->aliasedDeclaration().declaration();
   }
   if(decl) {
     if(m_currentToolTipDeclaration == IndexedDeclaration(decl) && m_currentToolTip)
       return nullptr;
 
     m_currentToolTipDeclaration = IndexedDeclaration(decl);
     return decl->context()->createNavigationWidget(decl, DUChainUtils::standardContextForUrl(viewUrl));
   }
 
   if (topContext) {
     // second pass: find closest problem to the cursor
     const auto problems = findProblemsCloseToCursor(topContext, position, view);
     if (!problems.isEmpty()) {
       if (problems == m_currentToolTipProblems && m_currentToolTip) {
         return nullptr;
       }
 
       m_currentToolTipProblems = problems;
       auto widget = new AbstractNavigationWidget;
       // since the problem is not under cursor: show location
       widget->setContext(NavigationContextPointer(new ProblemNavigationContext(problems, ProblemNavigationContext::ShowLocation)));
       return widget;
     }
   }
 
   return nullptr;
 }
 
 void ContextBrowserPlugin::showToolTip(KTextEditor::View* view, KTextEditor::Cursor position) {
   ContextBrowserView* contextView = browserViewForWidget(view);
   if(contextView && contextView->isVisible() && !contextView->isLocked())
     return; // If the context-browser view is visible, it will care about updating by itself
 
   auto navigationWidget = navigationWidgetForPosition(view, position);
   if(navigationWidget) {
 
     // If we have an invisible context-view, assign the tooltip navigation-widget to it.
     // If the user makes the context-view visible, it will instantly contain the correct widget.
     if(contextView && !contextView->isLocked())
       contextView->setNavigationWidget(navigationWidget);
 
     if(m_currentToolTip) {
       m_currentToolTip->deleteLater();
       m_currentToolTip = nullptr;
       m_currentNavigationWidget = nullptr;
     }
 
     KDevelop::NavigationToolTip* tooltip = new KDevelop::NavigationToolTip(view, view->mapToGlobal(view->cursorToCoordinate(position)) + QPoint(20, 40), navigationWidget);
     KTextEditor::Range itemRange;
     {
       DUChainReadLocker lock;
       auto viewUrl = view->document()->url();
       itemRange = DUChainUtils::itemUnderCursor(viewUrl, position).range;
     }
-    tooltip->setHandleRect(KTextEditorHelpers::getItemBoundingRect(view, itemRange));
+    tooltip->setHandleRect(KTextEditorHelpers::itemBoundingRect(view, itemRange));
     tooltip->resize( navigationWidget->sizeHint() + QSize(10, 10) );
     QObject::connect( view, &KTextEditor::View::verticalScrollPositionChanged,
                       this, &ContextBrowserPlugin::hideToolTip );
     QObject::connect( view, &KTextEditor::View::horizontalScrollPositionChanged,
                       this, &ContextBrowserPlugin::hideToolTip );
     qCDebug(PLUGIN_CONTEXTBROWSER) << "tooltip size" << tooltip->size();
     m_currentToolTip = tooltip;
     m_currentNavigationWidget = navigationWidget;
     ActiveToolTip::showToolTip(tooltip);
 
     if ( ! navigationWidget->property("DoNotCloseOnCursorMove").toBool() ) {
       connect(view, &View::cursorPositionChanged,
               this, &ContextBrowserPlugin::hideToolTip, Qt::UniqueConnection);
     } else {
       disconnect(view, &View::cursorPositionChanged,
                  this, &ContextBrowserPlugin::hideToolTip);
     }
   }else{
     qCDebug(PLUGIN_CONTEXTBROWSER) << "not showing tooltip, no navigation-widget";
   }
 }
 
 void ContextBrowserPlugin::clearMouseHover() {
   m_mouseHoverCursor = KTextEditor::Cursor::invalid();
   m_mouseHoverDocument.clear();
 }
 
 Attribute::Ptr ContextBrowserPlugin::highlightedUseAttribute(KTextEditor::View* view) const {
   if( !m_highlightAttribute ) {
     m_highlightAttribute = Attribute::Ptr( new Attribute() );
     m_highlightAttribute->setDefaultStyle(KTextEditor::dsNormal);
     m_highlightAttribute->setForeground(m_highlightAttribute->selectedForeground());
     m_highlightAttribute->setBackgroundFillWhitespace(true);
 
     auto iface = qobject_cast<KTextEditor::ConfigInterface*>(view);
     auto background = iface->configValue(QStringLiteral("search-highlight-color")).value<QColor>();
     m_highlightAttribute->setBackground(background);
   }
   return m_highlightAttribute;
 }
 
 void ContextBrowserPlugin::colorSetupChanged() {
   m_highlightAttribute = Attribute::Ptr();
 }
 
 Attribute::Ptr ContextBrowserPlugin::highlightedSpecialObjectAttribute(KTextEditor::View* view) const {
   return highlightedUseAttribute(view);
 }
 
 void ContextBrowserPlugin::addHighlight( View* view, KDevelop::Declaration* decl ) {
   if( !view || !decl ) {
     qCDebug(PLUGIN_CONTEXTBROWSER) << "invalid view/declaration";
     return;
   }
 
   ViewHighlights& highlights(m_highlightedRanges[view]);
 
   KDevelop::DUChainReadLocker lock;
 
   // Highlight the declaration
   highlights.highlights << decl->createRangeMoving();
   highlights.highlights.back()->setAttribute(highlightedUseAttribute(view));
   highlights.highlights.back()->setZDepth(highlightingZDepth);
 
   // Highlight uses
   {
     const auto currentRevisionUses = decl->usesCurrentRevision();
     for (auto fileIt = currentRevisionUses.constBegin(); fileIt != currentRevisionUses.constEnd(); ++fileIt) {
       for (auto useIt = (*fileIt).constBegin(); useIt != (*fileIt).constEnd(); ++useIt) {
         highlights.highlights << PersistentMovingRange::Ptr(new PersistentMovingRange(*useIt, fileIt.key()));
         highlights.highlights.back()->setAttribute(highlightedUseAttribute(view));
         highlights.highlights.back()->setZDepth(highlightingZDepth);
       }
     }
   }
 
   if( FunctionDefinition* def = FunctionDefinition::definition(decl) )
   {
     highlights.highlights << def->createRangeMoving();
     highlights.highlights.back()->setAttribute(highlightedUseAttribute(view));
     highlights.highlights.back()->setZDepth(highlightingZDepth);
   }
 }
 
 Declaration* ContextBrowserPlugin::findDeclaration(View* view, const KTextEditor::Cursor& position, bool mouseHighlight)
 {
       Q_UNUSED(mouseHighlight);
       Declaration* foundDeclaration = nullptr;
       if(m_useDeclaration.data()) {
         foundDeclaration = m_useDeclaration.data();
       }else{
         //If we haven't found a special language object, search for a use/declaration and eventually highlight it
         foundDeclaration = DUChainUtils::declarationForDefinition( DUChainUtils::itemUnderCursor(view->document()->url(), position).declaration );
         if (foundDeclaration && foundDeclaration->kind() == Declaration::Alias) {
           AliasDeclaration* alias = dynamic_cast<AliasDeclaration*>(foundDeclaration);
           Q_ASSERT(alias);
           DUChainReadLocker lock;
           foundDeclaration = alias->aliasedDeclaration().declaration();
         }
       }
       return foundDeclaration;
 }
 
 ContextBrowserView* ContextBrowserPlugin::browserViewForWidget(QWidget* widget)
 {
   foreach(ContextBrowserView* contextView, m_views) {
     if(masterWidget(contextView) == masterWidget(widget)) {
       return contextView;
     }
   }
 
   return nullptr;
 }
 
 void ContextBrowserPlugin::updateForView(View* view)
 {
     bool allowHighlight = true;
     if(view->selection())
     {
       // If something is selected, we unhighlight everything, so that we don't conflict with the
       // kate plugin that highlights occurrences of the selected string, and also to reduce the
       // overall amount of concurrent highlighting.
       allowHighlight = false;
     }
 
     if(m_highlightedRanges[view].keep)
     {
       m_highlightedRanges[view].keep = false;
       return;
     }
 
     // Clear all highlighting
     m_highlightedRanges.clear();
 
     // Re-highlight
     ViewHighlights& highlights = m_highlightedRanges[view];
 
     QUrl url = view->document()->url();
     IDocument* activeDoc = core()->documentController()->activeDocument();
 
     bool mouseHighlight = (url == m_mouseHoverDocument) && (m_mouseHoverCursor.isValid());
     bool shouldUpdateBrowser = (mouseHighlight || (view == ICore::self()->documentController()->activeTextDocumentView() && activeDoc && activeDoc->textDocument() == view->document()));
 
     KTextEditor::Cursor highlightPosition;
     if (mouseHighlight)
      highlightPosition = m_mouseHoverCursor;
     else
      highlightPosition = KTextEditor::Cursor(view->cursorPosition());
 
     ///Pick a language
     ILanguageSupport* language = nullptr;
 
     if(ICore::self()->languageController()->languagesForUrl(url).isEmpty()) {
       qCDebug(PLUGIN_CONTEXTBROWSER) << "found no language for document" << url;
       return;
     }else{
       language = ICore::self()->languageController()->languagesForUrl(url).front();
     }
 
     ///Check whether there is a special language object to highlight (for example a macro)
 
     KTextEditor::Range specialRange = language->specialLanguageObjectRange(url, highlightPosition);
     ContextBrowserView* updateBrowserView = shouldUpdateBrowser ?  browserViewForWidget(view) : nullptr;
 
     if(specialRange.isValid())
     {
       // Highlight a special language object
       if(allowHighlight)
       {
         highlights.highlights << PersistentMovingRange::Ptr(new PersistentMovingRange(specialRange, IndexedString(url)));
         highlights.highlights.back()->setAttribute(highlightedSpecialObjectAttribute(view));
         highlights.highlights.back()->setZDepth(highlightingZDepth);
       }
       if(updateBrowserView)
         updateBrowserView->setSpecialNavigationWidget(language->specialLanguageObjectNavigationWidget(url, highlightPosition));
     }else{
       KDevelop::DUChainReadLocker lock( DUChain::lock(), 100 );
       if(!lock.locked()) {
         qCDebug(PLUGIN_CONTEXTBROWSER) << "Failed to lock du-chain in time";
         return;
       }
 
       TopDUContext* topContext = DUChainUtils::standardContextForUrl(view->document()->url());
       if (!topContext)
         return;
       DUContext* ctx = contextForHighlightingAt(highlightPosition, topContext);
       if (!ctx)
         return;
 
       //Only update the history if this context is around the text cursor
       if(core()->documentController()->activeDocument() && highlightPosition == KTextEditor::Cursor(view->cursorPosition()) && view->document() == core()->documentController()->activeDocument()->textDocument())
       {
         updateHistory(ctx, highlightPosition);
       }
 
       Declaration* foundDeclaration = findDeclaration(view, highlightPosition, mouseHighlight);
 
       if( foundDeclaration ) {
         m_lastHighlightedDeclaration = highlights.declaration = IndexedDeclaration(foundDeclaration);
         if(allowHighlight)
           addHighlight( view, foundDeclaration );
 
         if(updateBrowserView)
           updateBrowserView->setDeclaration(foundDeclaration, topContext);
       }else{
         if(updateBrowserView)
           updateBrowserView->setContext(ctx);
       }
     }
 }
 
 void ContextBrowserPlugin::updateViews()
 {
   foreach( View* view, m_updateViews ) {
     updateForView(view);
   }
   m_updateViews.clear();
   m_useDeclaration = IndexedDeclaration();
 }
 
 void ContextBrowserPlugin::declarationSelectedInUI(const DeclarationPointer& decl)
 {
   m_useDeclaration = IndexedDeclaration(decl.data());
   KTextEditor::View* view = core()->documentController()->activeTextDocumentView();
   if(view)
     m_updateViews << view;
 
   if(!m_updateViews.isEmpty())
     m_updateTimer->start(highlightingTimeout); // triggers updateViews()
 }
 
 void ContextBrowserPlugin::updateReady(const IndexedString& file, const ReferencedTopDUContext& /*topContext*/)
 {
   const auto url = file.toUrl();
   for(QMap< View*, ViewHighlights >::iterator it = m_highlightedRanges.begin(); it != m_highlightedRanges.end(); ++it) {
     if(it.key()->document()->url() == url) {
 
       if(!m_updateViews.contains(it.key())) {
         qCDebug(PLUGIN_CONTEXTBROWSER) << "adding view for update";
         m_updateViews << it.key();
 
         // Don't change the highlighted declaration after finished parse-jobs
         (*it).keep = true;
       }
     }
   }
   if(!m_updateViews.isEmpty())
         m_updateTimer->start(highlightingTimeout);
 }
 
 void ContextBrowserPlugin::textDocumentCreated( KDevelop::IDocument* document )
 {
   Q_ASSERT(document->textDocument());
 
   connect( document->textDocument(), &KTextEditor::Document::viewCreated, this, &ContextBrowserPlugin::viewCreated );
 
   foreach( View* view, document->textDocument()->views() )
     viewCreated( document->textDocument(), view );
 }
 
 void ContextBrowserPlugin::documentActivated( IDocument* doc )
 {
   if (m_outlineLine)
     m_outlineLine->clear();
 
   if (View* view = doc->activeTextView())
   {
     cursorPositionChanged(view, view->cursorPosition());
   }
 }
 
 void ContextBrowserPlugin::viewDestroyed( QObject* obj )
 {
   m_highlightedRanges.remove(static_cast<KTextEditor::View*>(obj));
   m_updateViews.remove(static_cast<View*>(obj));
 }
 
 void ContextBrowserPlugin::selectionChanged( View* view )
 {
   clearMouseHover();
   m_updateViews.insert(view);
   m_updateTimer->start(highlightingTimeout/2); // triggers updateViews()
 }
 
 void ContextBrowserPlugin::cursorPositionChanged( View* view, const KTextEditor::Cursor& newPosition )
 {
   if(view->document() == m_lastInsertionDocument && newPosition == m_lastInsertionPos)
   {
     //Do not update the highlighting while typing
     m_lastInsertionDocument = nullptr;
     m_lastInsertionPos = KTextEditor::Cursor();
     if(m_highlightedRanges.contains(view))
       m_highlightedRanges[view].keep = true;
   }else{
     if(m_highlightedRanges.contains(view))
       m_highlightedRanges[view].keep = false;
   }
   clearMouseHover();
   m_updateViews.insert(view);
   m_updateTimer->start(highlightingTimeout/2); // triggers updateViews()
 }
 
 void ContextBrowserPlugin::textInserted(KTextEditor::Document* doc, const KTextEditor::Cursor& cursor, const QString& text)
 {
   m_lastInsertionDocument = doc;
   m_lastInsertionPos = cursor + KTextEditor::Cursor(0, text.size());
 }
 
 void ContextBrowserPlugin::viewCreated( KTextEditor::Document* , View* v )
 {
   disconnect( v, &View::cursorPositionChanged, this, &ContextBrowserPlugin::cursorPositionChanged ); ///Just to make sure that multiple connections don't happen
   connect( v, &View::cursorPositionChanged, this, &ContextBrowserPlugin::cursorPositionChanged );
   connect( v, &View::destroyed, this, &ContextBrowserPlugin::viewDestroyed );
   disconnect( v->document(), &KTextEditor::Document::textInserted, this, &ContextBrowserPlugin::textInserted);
   connect(v->document(), &KTextEditor::Document::textInserted, this, &ContextBrowserPlugin::textInserted);
   disconnect(v, &View::selectionChanged, this, &ContextBrowserPlugin::selectionChanged);
 
   KTextEditor::TextHintInterface *iface = dynamic_cast<KTextEditor::TextHintInterface*>(v);
   if( !iface )
       return;
 
   iface->setTextHintDelay(highlightingTimeout);
   iface->registerTextHintProvider(&m_textHintProvider);
 }
 
 void ContextBrowserPlugin::registerToolView(ContextBrowserView* view)
 {
   m_views << view;
 }
 
 void ContextBrowserPlugin::previousUseShortcut()
 {
   switchUse(false);
 }
 
 void ContextBrowserPlugin::nextUseShortcut()
 {
   switchUse(true);
 }
 
 KTextEditor::Range cursorToRange(KTextEditor::Cursor cursor) {
   return KTextEditor::Range(cursor, cursor);
 }
 
 void ContextBrowserPlugin::switchUse(bool forward)
 {
   View* view = core()->documentController()->activeTextDocumentView();
   if(view) {
     KTextEditor::Document* doc = view->document();
     KDevelop::DUChainReadLocker lock( DUChain::lock() );
     KDevelop::TopDUContext* chosen = DUChainUtils::standardContextForUrl(doc->url());
 
     if( chosen )
     {
       KTextEditor::Cursor cCurrent(view->cursorPosition());
       KDevelop::CursorInRevision c = chosen->transformToLocalRevision(cCurrent);
 
       Declaration* decl = nullptr;
       //If we have a locked declaration, use that for jumping
       foreach(ContextBrowserView* view, m_views) {
         decl = view->lockedDeclaration().data(); ///@todo Somehow match the correct context-browser view if there is multiple
         if(decl)
           break;
       }
 
       if(!decl) //Try finding a declaration under the cursor
         decl = DUChainUtils::itemUnderCursor(doc->url(), cCurrent).declaration;
 
       if (decl && decl->kind() == Declaration::Alias) {
         AliasDeclaration* alias = dynamic_cast<AliasDeclaration*>(decl);
         Q_ASSERT(alias);
         DUChainReadLocker lock;
         decl = alias->aliasedDeclaration().declaration();
       }
 
       if(decl) {
 
         Declaration* target = nullptr;
         if(forward)
           //Try jumping from definition to declaration
           target = DUChainUtils::declarationForDefinition(decl, chosen);
         else if(decl->url().toUrl() == doc->url() && decl->range().contains(c))
           //Try jumping from declaration to definition
           target = FunctionDefinition::definition(decl);
 
         if(target && target != decl) {
           KTextEditor::Cursor jumpTo = target->rangeInCurrentRevision().start();
           QUrl document = target->url().toUrl();
           lock.unlock();
           core()->documentController()->openDocument( document, cursorToRange(jumpTo)  );
           return;
         }else{
           //Always work with the declaration instead of the definition
           decl = DUChainUtils::declarationForDefinition(decl, chosen);
         }
       }
 
       if(!decl) {
         //Pick the last use we have highlighted
         decl = m_lastHighlightedDeclaration.data();
       }
 
       if(decl) {
         KDevVarLengthArray<IndexedTopDUContext> usingFiles = DUChain::uses()->uses(decl->id());
 
         if(DUChainUtils::contextHasUse(decl->topContext(), decl) && usingFiles.indexOf(decl->topContext()) == -1)
           usingFiles.insert(0, decl->topContext());
 
         if(decl->range().contains(c) && decl->url() == chosen->url()) {
             //The cursor is directly on the declaration. Jump to the first or last use.
             if(!usingFiles.isEmpty()) {
             TopDUContext* top = (forward ? usingFiles[0] : usingFiles.back()).data();
             if(top) {
               QVector<RangeInRevision> useRanges = allUses(top, decl, true);
               std::sort(useRanges.begin(), useRanges.end());
               if(!useRanges.isEmpty()) {
                 QUrl url = top->url().toUrl();
                 KTextEditor::Range selectUse = chosen->transformFromLocalRevision(forward ? useRanges.first() : useRanges.back());
                 lock.unlock();
                 core()->documentController()->openDocument(url, cursorToRange(selectUse.start()));
               }
             }
           }
           return;
         }
         //Check whether we are within a use
         QVector<RangeInRevision> localUses = allUses(chosen, decl, true);
         std::sort(localUses.begin(), localUses.end());
         for(int a = 0; a < localUses.size(); ++a) {
           int nextUse = (forward ? a+1 : a-1);
           bool pick = localUses[a].contains(c);
 
           if(!pick && forward && a+1 < localUses.size() && localUses[a].end <= c && localUses[a+1].start > c) {
             //Special case: We aren't on a use, but we are jumping forward, and are behind this and the next use
             pick = true;
           }
           if(!pick && !forward && a-1 >= 0 && c < localUses[a].start && c >= localUses[a-1].end) {
             //Special case: We aren't on a use, but we are jumping backward, and are in front of this use, but behind the previous one
             pick = true;
           }
           if(!pick && a == 0 && c < localUses[a].start) {
             if(!forward) {
               //Will automatically jump to previous file
             }else{
               nextUse = 0; //We are before the first use, so jump to it.
             }
             pick = true;
           }
           if(!pick && a == localUses.size()-1 && c >= localUses[a].end) {
             if(forward) {
               //Will automatically jump to next file
             }else{ //We are behind the last use, but moving backward. So pick the last use.
               nextUse = a;
             }
             pick = true;
           }
 
           if(pick) {
 
           //Make sure we end up behind the use
           if(nextUse != a)
             while(forward && nextUse < localUses.size() && (localUses[nextUse].start <= localUses[a].end || localUses[nextUse].isEmpty()))
               ++nextUse;
 
           //Make sure we end up before the use
           if(nextUse != a)
             while(!forward && nextUse >= 0 && (localUses[nextUse].start >= localUses[a].start || localUses[nextUse].isEmpty()))
               --nextUse;
           //Jump to the next use
 
           qCDebug(PLUGIN_CONTEXTBROWSER) << "count of uses:" << localUses.size() << "nextUse" << nextUse;
 
           if(nextUse < 0 || nextUse == localUses.size()) {
             qCDebug(PLUGIN_CONTEXTBROWSER) << "jumping to next file";
             //Jump to the first use in the next using top-context
             int indexInFiles = usingFiles.indexOf(chosen);
             if(indexInFiles != -1) {
 
               int nextFile = (forward ? indexInFiles+1 : indexInFiles-1);
               qCDebug(PLUGIN_CONTEXTBROWSER) << "current file" << indexInFiles << "nextFile" << nextFile;
 
               if(nextFile < 0 || nextFile >= usingFiles.size()) {
                 //Open the declaration, or the definition
                 if(nextFile >= usingFiles.size()) {
                   Declaration* definition = FunctionDefinition::definition(decl);
                   if(definition)
                     decl = definition;
                 }
                 QUrl u = decl->url().toUrl();
                 KTextEditor::Range range = decl->rangeInCurrentRevision();
                 range.setEnd(range.start());
                 lock.unlock();
                 core()->documentController()->openDocument(u, range);
                 return;
               }else{
                 TopDUContext* nextTop = usingFiles[nextFile].data();
 
                 QUrl u = nextTop->url().toUrl();
 
                 QVector<RangeInRevision> nextTopUses = allUses(nextTop, decl, true);
                 std::sort(nextTopUses.begin(), nextTopUses.end());
 
                 if(!nextTopUses.isEmpty()) {
                   KTextEditor::Range range =  chosen->transformFromLocalRevision(forward ? nextTopUses.front() : nextTopUses.back());
                   range.setEnd(range.start());
                   lock.unlock();
                   core()->documentController()->openDocument(u, range);
                 }
                 return;
               }
             }else{
               qCDebug(PLUGIN_CONTEXTBROWSER) << "not found own file in use list";
             }
           }else{
               QUrl url = chosen->url().toUrl();
               KTextEditor::Range range = chosen->transformFromLocalRevision(localUses[nextUse]);
               range.setEnd(range.start());
               lock.unlock();
               core()->documentController()->openDocument(url, range);
               return;
           }
         }
         }
       }
     }
   }
 }
 
 void ContextBrowserPlugin::unRegisterToolView(ContextBrowserView* view)
 {
   m_views.removeAll(view);
 }
 
 // history browsing
 
 QWidget* ContextBrowserPlugin::toolbarWidgetForMainWindow( Sublime::MainWindow* window )
 {
   //TODO: support multiple windows (if that ever gets revived)
   if (!m_toolbarWidget) {
     m_toolbarWidget = new QWidget(window);
   }
   return m_toolbarWidget;
 }
 
 void ContextBrowserPlugin::documentJumpPerformed( KDevelop::IDocument* newDocument,
                                             const KTextEditor::Cursor& newCursor,
                                             KDevelop::IDocument* previousDocument,
                                             const KTextEditor::Cursor& previousCursor) {
 
     DUChainReadLocker lock(DUChain::lock());
 
     /*TODO: support multiple windows if that ever gets revived
     if(newDocument && newDocument->textDocument() && newDocument->textDocument()->activeView() && masterWidget(newDocument->textDocument()->activeView()) != masterWidget(this))
         return;
     */
 
     if(previousDocument && previousCursor.isValid()) {
         qCDebug(PLUGIN_CONTEXTBROWSER) << "updating jump source";
         DUContext* context = contextAt(previousDocument->url(), previousCursor);
         if(context) {
             updateHistory(context, KTextEditor::Cursor(previousCursor), true);
         }else{
             //We just want this place in the history
             m_history.resize(m_nextHistoryIndex); // discard forward history
             m_history.append(HistoryEntry(DocumentCursor(IndexedString(previousDocument->url()), KTextEditor::Cursor(previousCursor))));
             ++m_nextHistoryIndex;
         }
     }
     qCDebug(PLUGIN_CONTEXTBROWSER) << "new doc: " << newDocument << " new cursor: " << newCursor;
     if(newDocument && newCursor.isValid()) {
         qCDebug(PLUGIN_CONTEXTBROWSER) << "updating jump target";
         DUContext* context = contextAt(newDocument->url(), newCursor);
         if(context) {
             updateHistory(context, KTextEditor::Cursor(newCursor), true);
         }else{
             //We just want this place in the history
             m_history.resize(m_nextHistoryIndex); // discard forward history
             m_history.append(HistoryEntry(DocumentCursor(IndexedString(newDocument->url()), KTextEditor::Cursor(newCursor))));
             ++m_nextHistoryIndex;
             if (m_outlineLine) m_outlineLine->clear();
         }
     }
 }
 
 void ContextBrowserPlugin::updateButtonState()
 {
     m_nextButton->setEnabled( m_nextHistoryIndex < m_history.size() );
     m_previousButton->setEnabled( m_nextHistoryIndex >= 2 );
 }
 
 void ContextBrowserPlugin::historyNext() {
     if(m_nextHistoryIndex >= m_history.size()) {
         return;
     }
     openDocument(m_nextHistoryIndex); // opening the document at given position
                                       // will update the widget for us
     ++m_nextHistoryIndex;
     updateButtonState();
 }
 
 void ContextBrowserPlugin::openDocument(int historyIndex) {
     Q_ASSERT_X(historyIndex >= 0, "openDocument", "negative history index");
     Q_ASSERT_X(historyIndex < m_history.size(), "openDocument", "history index out of range");
     DocumentCursor c = m_history[historyIndex].computePosition();
     if (c.isValid() && !c.document.str().isEmpty()) {
 
         disconnect(ICore::self()->documentController(), &IDocumentController::documentJumpPerformed, this,      &ContextBrowserPlugin::documentJumpPerformed);
 
         ICore::self()->documentController()->openDocument(c.document.toUrl(), c);
 
         connect(ICore::self()->documentController(), &IDocumentController::documentJumpPerformed, this, &ContextBrowserPlugin::documentJumpPerformed);
 
         KDevelop::DUChainReadLocker lock( KDevelop::DUChain::lock() );
         updateDeclarationListBox(m_history[historyIndex].context.data());
     }
 }
 
 void ContextBrowserPlugin::historyPrevious() {
     if(m_nextHistoryIndex < 2) {
         return;
     }
     --m_nextHistoryIndex;
     openDocument(m_nextHistoryIndex-1); // opening the document at given position
                                         // will update the widget for us
     updateButtonState();
 }
 
 QString ContextBrowserPlugin::actionTextFor(int historyIndex) const
 {
     const HistoryEntry& entry = m_history.at(historyIndex);
     QString actionText = entry.context.data() ? entry.context.data()->scopeIdentifier(true).toString() : QString();
     if(actionText.isEmpty())
         actionText = entry.alternativeString;
     if(actionText.isEmpty())
         actionText = QStringLiteral("<unnamed>");
     actionText += QLatin1String(" @ ");
     QString fileName = entry.absoluteCursorPosition.document.toUrl().fileName();
     actionText += QStringLiteral("%1:%2").arg(fileName).arg(entry.absoluteCursorPosition.line()+1);
     return actionText;
 }
 
 /*
 inline QDebug operator<<(QDebug debug, const ContextBrowserPlugin::HistoryEntry &he)
 {
     DocumentCursor c = he.computePosition();
     debug << "\n\tHistoryEntry " << c.line << " " << c.document.str();
     return debug;
 }
 */
 
 void ContextBrowserPlugin::nextMenuAboutToShow() {
     QList<int> indices;
     indices.reserve(m_history.size()-m_nextHistoryIndex);
     for(int a = m_nextHistoryIndex; a < m_history.size(); ++a) {
         indices << a;
     }
     fillHistoryPopup(m_nextMenu, indices);
 }
 
 void ContextBrowserPlugin::previousMenuAboutToShow() {
     QList<int> indices;
     indices.reserve(m_nextHistoryIndex-1);
     for(int a = m_nextHistoryIndex-2; a >= 0; --a) {
         indices << a;
     }
     fillHistoryPopup(m_previousMenu, indices);
 }
 
 void ContextBrowserPlugin::fillHistoryPopup(QMenu* menu, const QList<int>& historyIndices) {
     menu->clear();
     KDevelop::DUChainReadLocker lock( KDevelop::DUChain::lock() );
     for (int index : historyIndices) {
         QAction* action = new QAction(actionTextFor(index), menu);
         action->setData(index);
         menu->addAction(action);
         connect(action, &QAction::triggered, this, &ContextBrowserPlugin::actionTriggered);
     }
 }
 
 bool ContextBrowserPlugin::isPreviousEntry(KDevelop::DUContext* context,
                                            const KTextEditor::Cursor& /*position*/) const
 {
     if (m_nextHistoryIndex == 0) return false;
     Q_ASSERT(m_nextHistoryIndex <= m_history.count());
     const HistoryEntry& he = m_history.at(m_nextHistoryIndex-1);
     KDevelop::DUChainReadLocker lock( KDevelop::DUChain::lock() ); // is this necessary??
     Q_ASSERT(context);
     return IndexedDUContext(context) == he.context;
 }
 
 void ContextBrowserPlugin::updateHistory(KDevelop::DUContext* context, const KTextEditor::Cursor& position, bool force)
 {
     qCDebug(PLUGIN_CONTEXTBROWSER) << "updating history";
 
     if(m_outlineLine && m_outlineLine->isVisible())
         updateDeclarationListBox(context);
 
     if(!context || (!context->owner() && !force)) {
         return; //Only add history-entries for contexts that have owners, which in practice should be functions and classes
                 //This keeps the history cleaner
     }
 
     if (isPreviousEntry(context, position)) {
         if(m_nextHistoryIndex) {
             HistoryEntry& he = m_history[m_nextHistoryIndex-1];
             he.setCursorPosition(position);
         }
         return;
     } else { // Append new history entry
         m_history.resize(m_nextHistoryIndex); // discard forward history
         m_history.append(HistoryEntry(IndexedDUContext(context), position));
         ++m_nextHistoryIndex;
 
         updateButtonState();
         if(m_history.size() > (maxHistoryLength + 5)) {
             m_history.remove(0, m_history.size() - maxHistoryLength);
             m_nextHistoryIndex = m_history.size();
         }
     }
 }
 
 void ContextBrowserPlugin::updateDeclarationListBox(DUContext* context) {
     if(!context || !context->owner()) {
         qCDebug(PLUGIN_CONTEXTBROWSER) << "not updating box";
         m_listUrl = IndexedString(); ///@todo Compute the context in the document here
         if (m_outlineLine) m_outlineLine->clear();
         return;
     }
 
     Declaration* decl = context->owner();
 
     m_listUrl = context->url();
 
     Declaration* specialDecl = SpecializationStore::self().applySpecialization(decl, decl->topContext());
 
     FunctionType::Ptr function = specialDecl->type<FunctionType>();
     QString text = specialDecl->qualifiedIdentifier().toString();
     if(function)
         text += function->partToString(KDevelop::FunctionType::SignatureArguments);
 
     if(m_outlineLine && !m_outlineLine->hasFocus())
     {
         m_outlineLine->setText(text);
         m_outlineLine->setCursorPosition(0);
     }
 
     qCDebug(PLUGIN_CONTEXTBROWSER) << "updated" << text;
 }
 
 void ContextBrowserPlugin::actionTriggered() {
     QAction* action = qobject_cast<QAction*>(sender());
     Q_ASSERT(action); Q_ASSERT(action->data().type() == QVariant::Int);
     int historyPosition = action->data().toInt();
     // qCDebug(PLUGIN_CONTEXTBROWSER) << "history pos" << historyPosition << m_history.size() << m_history;
     if(historyPosition >= 0 && historyPosition < m_history.size()) {
         m_nextHistoryIndex = historyPosition + 1;
         openDocument(historyPosition);
         updateButtonState();
     }
 }
 
 void ContextBrowserPlugin::doNavigate(NavigationActionType action)
 {
   KTextEditor::View* view = qobject_cast<KTextEditor::View*>(sender());
   if(!view) {
       qCWarning(PLUGIN_CONTEXTBROWSER) << "sender is not a view";
       return;
   }
   KTextEditor::CodeCompletionInterface* iface = qobject_cast<KTextEditor::CodeCompletionInterface*>(view);
   if(!iface || iface->isCompletionActive())
       return; // If code completion is active, the actions should be handled by the completion widget
 
   QWidget* widget = m_currentNavigationWidget.data();
 
   if(!widget || !widget->isVisible())
   {
     ContextBrowserView* contextView = browserViewForWidget(view);
     if(contextView)
       widget = contextView->navigationWidget();
   }
 
   if(widget)
   {
     AbstractNavigationWidget* navWidget = qobject_cast<AbstractNavigationWidget*>(widget);
     if (navWidget)
     {
       switch(action) {
         case Accept:
           navWidget->accept();
           break;
         case Back:
           navWidget->back();
           break;
         case Left:
           navWidget->previous();
           break;
         case Right:
           navWidget->next();
           break;
         case Up:
           navWidget->up();
           break;
         case Down:
           navWidget->down();
           break;
       }
     }
   }
 }
 
 void ContextBrowserPlugin::navigateAccept() {
   doNavigate(Accept);
 }
 
 void ContextBrowserPlugin::navigateBack() {
   doNavigate(Back);
 }
 
 void ContextBrowserPlugin::navigateDown() {
   doNavigate(Down);
 }
 
 void ContextBrowserPlugin::navigateLeft() {
   doNavigate(Left);
 }
 
 void ContextBrowserPlugin::navigateRight() {
   doNavigate(Right);
 }
 
 void ContextBrowserPlugin::navigateUp() {
   doNavigate(Up);
 }
 
 
 //BEGIN HistoryEntry
 ContextBrowserPlugin::HistoryEntry::HistoryEntry(const KDevelop::DocumentCursor& pos)
   : absoluteCursorPosition(pos)
 {
 }
 
 ContextBrowserPlugin::HistoryEntry::HistoryEntry(IndexedDUContext ctx, const KTextEditor::Cursor& cursorPosition) : context(ctx) {
         //Use a position relative to the context
         setCursorPosition(cursorPosition);
         if(ctx.data())
             alternativeString = ctx.data()->scopeIdentifier(true).toString();
         if(!alternativeString.isEmpty())
             alternativeString += i18n("(changed)"); //This is used when the context was deleted in between
 }
 
 DocumentCursor ContextBrowserPlugin::HistoryEntry::computePosition() const {
     KDevelop::DUChainReadLocker lock( KDevelop::DUChain::lock() );
     DocumentCursor ret;
     if(context.data()) {
         ret = DocumentCursor(context.data()->url(), relativeCursorPosition);
         ret.setLine(ret.line() + context.data()->range().start.line);
     }else{
         ret = absoluteCursorPosition;
     }
     return ret;
 }
 
 void ContextBrowserPlugin::HistoryEntry::setCursorPosition(const KTextEditor::Cursor& cursorPosition) {
     KDevelop::DUChainReadLocker lock( KDevelop::DUChain::lock() );
     if(context.data()) {
         absoluteCursorPosition =  DocumentCursor(context.data()->url(), cursorPosition);
         relativeCursorPosition = cursorPosition;
         relativeCursorPosition.setLine(relativeCursorPosition.line() - context.data()->range().start.line);
     }
 }
 
 // kate: space-indent on; indent-width 2; tab-width 4; replace-tabs on; auto-insert-doxygen on
 
 #include "contextbrowser.moc"
diff --git a/plugins/contextbrowser/contextbrowserview.cpp b/plugins/contextbrowser/contextbrowserview.cpp
index 17f9986b0e..800ef7d08b 100644
--- a/plugins/contextbrowser/contextbrowserview.cpp
+++ b/plugins/contextbrowser/contextbrowserview.cpp
@@ -1,393 +1,393 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "contextbrowserview.h"
 
 #include <QVBoxLayout>
 #include <QIcon>
 #include <QMenu>
 #include <QShowEvent>
 #include <QTextBrowser>
 
 #include <KToggleAction>
 #include <KLocalizedString>
 #include <KTextEditor/Document>
 
 #include <language/duchain/declaration.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 
 #include <interfaces/icore.h>
 
 #include "contextbrowser.h"
 #include "debug.h"
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/specializationstore.h>
 #include "browsemanager.h"
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <language/interfaces/codecontext.h>
 #include <language/duchain/navigation/abstractdeclarationnavigationcontext.h>
 #include <language/duchain/navigation/useswidget.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/iplugincontroller.h>
 
 using namespace KDevelop;
 
 namespace {
 
 enum Direction
 {
     NextUse,
     PreviousUse
 };
 
 void selectUse(ContextBrowserView* view, Direction direction)
 {
     auto abstractNaviWidget = dynamic_cast<AbstractNavigationWidget*>(view->navigationWidget());
 
     if (!abstractNaviWidget) {
         return;
     }
 
     auto usesWidget = dynamic_cast<UsesWidget*>(abstractNaviWidget->context()->widget());
     if (!usesWidget) {
         return;
     }
 
     OneUseWidget* first = nullptr, *previous = nullptr, *current = nullptr;
     const auto& usesWidgetItems = usesWidget->items();
     for (auto item : usesWidgetItems) {
         auto topContext = dynamic_cast<TopContextUsesWidget*>(item);
         if (!topContext) {
             continue;
         }
         const auto& topContextItems = topContext->items();
         for (auto item : topContextItems) {
             auto navigationList = dynamic_cast<NavigatableWidgetList*>(item);
             if (!navigationList) {
                 continue;
             }
             const auto& navigationListItems = navigationList->items();
             for (auto item : navigationListItems) {
                 auto use = dynamic_cast<OneUseWidget*>(item);
                 if (!use) {
                     continue;
                 }
                 if (!first) {
                     first = use;
                 }
                 current = use;
                 if (direction == PreviousUse && current->isHighlighted() && previous) {
                     previous->setHighlighted(true);
                     previous->activateLink();
                     current->setHighlighted(false);
                     return;
                 }
                 if (direction == NextUse && previous && previous->isHighlighted()) {
                     current->setHighlighted(true);
                     current->activateLink();
                     previous->setHighlighted(false);
                     return;
                 }
                 previous = current;
             }
         }
     }
     if (direction == NextUse && first) {
         first->setHighlighted(true);
         first->activateLink();
         if (current && current->isHighlighted())
             current->setHighlighted(false);
         return;
     }
     if (direction == PreviousUse && current) {
         current->setHighlighted(true);
         current->activateLink();
         if (first && first->isHighlighted()) {
             first->setHighlighted(false);
         }
     }
 }
 
 }
 
 QWidget* ContextBrowserView::createWidget(KDevelop::DUContext* context) {
         m_context = IndexedDUContext(context);
         if(m_context.data()) {
             return m_context.data()->createNavigationWidget(nullptr, nullptr, {}, {}, AbstractNavigationWidget::EmbeddableWidget);
         }
         return nullptr;
 }
 
 KDevelop::IndexedDeclaration ContextBrowserView::declaration() const {
     return m_declaration;
 }
 
 QWidget* ContextBrowserView::createWidget(Declaration* decl, TopDUContext* topContext) {
     m_declaration = IndexedDeclaration(decl);
     return decl->context()->createNavigationWidget(decl, topContext, {}, {}, AbstractNavigationWidget::EmbeddableWidget);
 }
 
 
 void ContextBrowserView::resetWidget()
 {
     if (m_navigationWidget) {
         delete m_navigationWidget;
         m_navigationWidget = nullptr;
     }
 }
 
 void ContextBrowserView::declarationMenu() {
     DUChainReadLocker lock(DUChain::lock());
 
     AbstractNavigationWidget* navigationWidget = dynamic_cast<AbstractNavigationWidget*>(m_navigationWidget.data());
     if(navigationWidget) {
         AbstractDeclarationNavigationContext* navigationContext = dynamic_cast<AbstractDeclarationNavigationContext*>(navigationWidget->context().data());
         if(navigationContext && navigationContext->declaration().data()) {
             KDevelop::DeclarationContext* c = new KDevelop::DeclarationContext(navigationContext->declaration().data());
             lock.unlock();
             QMenu menu(this);
             QList<ContextMenuExtension> extensions = ICore::self()->pluginController()->queryPluginsForContextMenuExtensions(c, &menu);
 
             ContextMenuExtension::populateMenu(&menu, extensions);
             menu.exec(QCursor::pos());
         }
     }
 }
 
 ContextBrowserView::ContextBrowserView( ContextBrowserPlugin* plugin, QWidget* parent ) : QWidget(parent), m_plugin(plugin), m_navigationWidget(new QTextBrowser()), m_autoLocked(false) {
     setWindowTitle(i18n("Code Browser"));
     setWindowIcon( QIcon::fromTheme(QStringLiteral("code-context"), windowIcon()) );
 
     m_allowLockedUpdate = false;
 
     m_declarationMenuAction = new QAction(QIcon::fromTheme(QStringLiteral("code-class")), QString(), this);
     m_declarationMenuAction->setToolTip(i18n("Show declaration menu"));
     // expose the declaration menu via the context menu; allows hiding the toolbar to save some space
     // (this will not make it behave like a submenu though)
     m_declarationMenuAction->setText(i18n("Declaration Menu"));
     connect(m_declarationMenuAction, &QAction::triggered, this, &ContextBrowserView::declarationMenu);
     addAction(m_declarationMenuAction);
     m_lockAction = new KToggleAction(QIcon::fromTheme(QStringLiteral("object-unlocked")), i18n("Lock Current View"), this);
     m_lockAction->setToolTip(i18n("Lock current view"));
     m_lockAction->setCheckedState(KGuiItem(i18n("Unlock Current View"), QIcon::fromTheme(QStringLiteral("object-locked")), i18n("Unlock current view")));
     m_lockAction->setChecked(false);
     addAction(m_lockAction);
 
     m_layout = new QVBoxLayout;
     m_layout->setSpacing(0);
     m_layout->setMargin(0);
     m_layout->addWidget(m_navigationWidget);
     //m_layout->addStretch();
     setLayout(m_layout);
 
     m_plugin->registerToolView(this);
 }
 
 ContextBrowserView::~ContextBrowserView() {
     m_plugin->unRegisterToolView(this);
 }
 
 void ContextBrowserView::focusInEvent(QFocusEvent* event) {
     //Indicate that we have focus
     qCDebug(PLUGIN_CONTEXTBROWSER) << "got focus";
 //     parentWidget()->setBackgroundRole(QPalette::ToolTipBase);
 /*    m_layout->removeItem(m_buttons);*/
 
     QWidget::focusInEvent(event);
 }
 
 void ContextBrowserView::focusOutEvent(QFocusEvent* event) {
     qCDebug(PLUGIN_CONTEXTBROWSER) << "lost focus";
 //     parentWidget()->setBackgroundRole(QPalette::Background);
 /*    m_layout->insertLayout(0, m_buttons);
     for(int a = 0; a < m_buttons->count(); ++a) {
         QWidgetItem* item = dynamic_cast<QWidgetItem*>(m_buttons->itemAt(a));
     }*/
     QWidget::focusOutEvent(event);
 }
 
 bool ContextBrowserView::event(QEvent* event) {
     QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(event);
 
     if(hasFocus() && keyEvent) {
         AbstractNavigationWidget* navigationWidget = dynamic_cast<AbstractNavigationWidget*>(m_navigationWidget.data());
         if(navigationWidget && event->type() == QEvent::KeyPress) {
             int key = keyEvent->key();
             if(key == Qt::Key_Left)
                 navigationWidget->previous();
             if(key == Qt::Key_Right)
                 navigationWidget->next();
             if(key == Qt::Key_Up)
                 navigationWidget->up();
             if(key == Qt::Key_Down)
                 navigationWidget->down();
             if(key == Qt::Key_Return || key == Qt::Key_Enter)
                 navigationWidget->accept();
 
 
             if(key == Qt::Key_L)
                 m_lockAction->toggle();
         }
     }
     return QWidget::event(event);
 }
 
 void ContextBrowserView::showEvent(QShowEvent* event)
 {
     DUChainReadLocker lock(DUChain::lock(), 200);
     if (!lock.locked()) {
         QWidget::showEvent(event);
         return;
     }
 
     TopDUContext* top = m_lastUsedTopContext.data();
     if(top && m_navigationWidgetDeclaration.isValid()) {
         //Update the navigation-widget
-        Declaration* decl = m_navigationWidgetDeclaration.getDeclaration(top);
+        Declaration* decl = m_navigationWidgetDeclaration.declaration(top);
         if(decl)
             setDeclaration(decl, top, true);
     }
     QWidget::showEvent(event);
 }
 
 bool ContextBrowserView::isLocked() const {
     bool isLocked;
     if (m_allowLockedUpdate) {
         isLocked = false;
     } else {
         isLocked = m_lockAction->isChecked();
     }
     return isLocked;
 }
 
 void ContextBrowserView::updateMainWidget(QWidget* widget)
 {
     if (widget) {
         setUpdatesEnabled(false);
         qCDebug(PLUGIN_CONTEXTBROWSER) << "";
         resetWidget();
         m_navigationWidget = widget;
         m_layout->insertWidget(1, widget, 1);
         m_allowLockedUpdate = false;
         setUpdatesEnabled(true);
         if (widget->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("contextChanged(bool,bool)").constData()) != -1) {
             connect(widget, SIGNAL(contextChanged(bool,bool)), this, SLOT(navigationContextChanged(bool,bool)));
         }
     }
 }
 
 void ContextBrowserView::navigationContextChanged(bool wasInitial, bool isInitial)
 {
     if(wasInitial && !isInitial && !m_lockAction->isChecked())
     {
         m_autoLocked = true;
         m_lockAction->setChecked(true);
     }else if(!wasInitial && isInitial && m_autoLocked)
     {
         m_autoLocked = false;
         m_lockAction->setChecked(false);
     }else if(isInitial) {
         m_autoLocked = false;
     }
 }
 
 void ContextBrowserView::selectNextItem()
 {
     selectUse(this, NextUse);
 }
 
 void ContextBrowserView::selectPreviousItem()
 {
     selectUse(this, PreviousUse);
 }
 
 void ContextBrowserView::setDeclaration(KDevelop::Declaration* decl, KDevelop::TopDUContext* topContext, bool force) {
     m_lastUsedTopContext = IndexedTopDUContext(topContext);
 
     if(isLocked() && (!m_navigationWidget.data() || !isVisible()))
     {
         // Automatically remove the locked state if the view is not visible or the widget was deleted,
         // because the locked state has side-effects on other navigation functionality.
         m_autoLocked = false;
         m_lockAction->setChecked(false);
     }
 
     if(m_navigationWidgetDeclaration == decl->id() && !force)
         return;
 
     m_navigationWidgetDeclaration = decl->id();
 
     if (!isLocked() && (isVisible() || force)) {  // NO-OP if tool view is hidden, for performance reasons
 
         QWidget* w = createWidget(decl, topContext);
         updateMainWidget(w);
     }
 }
 
 KDevelop::IndexedDeclaration ContextBrowserView::lockedDeclaration() const {
     if(m_lockAction->isChecked())
         return declaration();
     else
         return KDevelop::IndexedDeclaration();
 }
 
 void ContextBrowserView::allowLockedUpdate() {
     m_allowLockedUpdate = true;
 }
 
 void ContextBrowserView::setNavigationWidget(QWidget* widget) {
     updateMainWidget(widget);
 }
 
 void ContextBrowserView::setContext(KDevelop::DUContext* context) {
     if(!context)
         return;
 
     m_lastUsedTopContext = IndexedTopDUContext(context->topContext());
 
     if(context->owner()) {
         if(context->owner()->id() == m_navigationWidgetDeclaration)
             return;
         m_navigationWidgetDeclaration = context->owner()->id();
     }else{
         m_navigationWidgetDeclaration = DeclarationId();
     }
 
     if (!isLocked() && isVisible()) { // NO-OP if tool view is hidden, for performance reasons
 
         QWidget* w = createWidget(context);
         updateMainWidget(w);
     }
 }
 
 void ContextBrowserView::setSpecialNavigationWidget(QWidget* widget) {
     if (!isLocked() && isVisible()) {
         Q_ASSERT(widget);
         updateMainWidget(widget);
     } else if(widget) {
         widget->deleteLater();
     }
 }
 
diff --git a/plugins/outlineview/outlinenode.cpp b/plugins/outlineview/outlinenode.cpp
index db6b285e70..adcffb5214 100644
--- a/plugins/outlineview/outlinenode.cpp
+++ b/plugins/outlineview/outlinenode.cpp
@@ -1,299 +1,299 @@
 /*
  *   KDevelop outline view
  *   Copyright 2010, 2015 Alex Richardson <alex.richardson@gmx.de>
  *
  *   This library is free software; you can redistribute it and/or
  *   modify it under the terms of the GNU Lesser General Public
  *   License as published by the Free Software Foundation; either
  *   version 2.1 of the License, or (at your option) 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
  *   Lesser General Public License for more details.
  *
  *   You should have received a copy of the GNU Lesser General Public
  *   License along with this library; if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "outlinenode.h"
 
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/classfunctiondeclaration.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/types/alltypes.h>
 #include <language/duchain/namespacealiasdeclaration.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/forwarddeclaration.h>
 
 #include <KTextEditor/CodeCompletionModel>
 
 #include <debug.h>
 
 using namespace KDevelop;
 
 OutlineNode::OutlineNode(const QString& text, OutlineNode* parent)
     : m_cachedText(text)
     , m_parent(parent)
 {
 }
 
 OutlineNode::OutlineNode(DUContext* ctx, const QString& name, OutlineNode* parent)
     : m_cachedText(name)
     , m_declOrContext(ctx)
     , m_parent(parent)
 {
     KTextEditor::CodeCompletionModel::CompletionProperties prop;
     switch (ctx->type()) {
         case KDevelop::DUContext::Class:
             prop |= KTextEditor::CodeCompletionModel::Class;
             break;
         case KDevelop::DUContext::Enum:
             prop |= KTextEditor::CodeCompletionModel::Enum;
             break;
         case KDevelop::DUContext::Function:
             prop |= KTextEditor::CodeCompletionModel::Function;
             break;
         case KDevelop::DUContext::Namespace:
             prop |= KTextEditor::CodeCompletionModel::Namespace;
             break;
         case KDevelop::DUContext::Template:
             prop |= KTextEditor::CodeCompletionModel::Template;
             break;
         default:
             break;
     }
     m_cachedIcon = DUChainUtils::iconForProperties(prop);
     appendContext(ctx, ctx->topContext());
 }
 
 
 OutlineNode::OutlineNode(Declaration* decl, OutlineNode* parent)
     : m_declOrContext(decl)
     , m_parent(parent)
 {
     // qCDebug(PLUGIN_OUTLINE) << "Adding:" << decl->qualifiedIdentifier().toString() << ": " <<typeid(*decl).name();
 
     // TODO: properly qualified identifier for out of line function definitions
     m_cachedText = decl->identifier().toString();
     m_cachedIcon = DUChainUtils::iconForDeclaration(decl);
     if (NamespaceAliasDeclaration* alias = dynamic_cast<NamespaceAliasDeclaration*>(decl)) {
         //e.g. C++ using namespace statement
         m_cachedText = alias->importIdentifier().toString();
     }
     else if (ClassMemberDeclaration* member = dynamic_cast<ClassMemberDeclaration*>(decl)) {
         if (member->isFriend()) {
             m_cachedText = QLatin1String("friend ") + m_cachedText;
         }
     }
     if (AbstractType::Ptr type = decl->abstractType()) {
         //add the (function return) type at the end (after a colon - like UML)
         //so that the first thing seen is the name of the function/variable
         //and not the (function return) type
         AbstractType::WhichType typeEnum = type->whichType();
         switch (typeEnum) {
         case AbstractType::TypeFunction: {
             FunctionType::Ptr func = type.cast<FunctionType>();
             // func->partToString() does not add the argument names -> do it manually
-            if (DUContext* fCtx = DUChainUtils::getFunctionContext(decl)) {
+            if (DUContext* fCtx = DUChainUtils::functionContext(decl)) {
                 m_cachedText += QLatin1Char('(');
                 bool first = true;
                 foreach (Declaration* childDecl, fCtx->localDeclarations(decl->topContext())) {
                     if (first) {
                         first = false;
                     } else {
                         m_cachedText += QStringLiteral(", ");
                     }
 
                     if (childDecl->abstractType()) {
                         m_cachedText += childDecl->abstractType()->toString();
                     }
                     auto ident = childDecl->identifier();
                     if (!ident.isEmpty()) {
                         m_cachedText += QLatin1Char(' ') +  ident.toString();
                     }
 
                 }
                 m_cachedText += QLatin1Char(')');
             } else {
                 qCWarning(PLUGIN_OUTLINE) << "Missing function context:" << decl->qualifiedIdentifier().toString();
                 m_cachedText += func->partToString(FunctionType::SignatureArguments);
             }
             //constructors/destructors have no return type, a trailing semicolon would look stupid
             if (func->returnType()) {
                 m_cachedText += QLatin1String(" : ") + func->partToString(FunctionType::SignatureReturn);
             }
             return; // don't append any children here!
         }
         case AbstractType::TypeEnumeration:
             //no need to append the fully qualified type
             break;
         case AbstractType::TypeEnumerator:
             //no need to append the fully qualified type
             Q_ASSERT(decl->type<EnumeratorType>());
             m_cachedText += QLatin1String(" = ") + decl->type<EnumeratorType>()->valueAsString();
             break;
         case AbstractType::TypeStructure: {
             //this seems to be the way it has to be done (after grepping through source code)
             //TODO shouldn't there be some kind of isFriend() functionality?
             static IndexedIdentifier friendIdentifier(Identifier(QStringLiteral("friend")));
             const bool isFriend = decl->indexedIdentifier() == friendIdentifier;
             if (isFriend) {
                 //FIXME There seems to be no way of finding out whether the friend is class/struct/etc
                 m_cachedText += QLatin1Char(' ') + type->toString();
             }
             break;
         }
         case AbstractType::TypeAlias: {
             //append the type it aliases
             TypeAliasType::Ptr alias = type.cast<TypeAliasType>();
             if (AbstractType::Ptr targetType = alias->type()) {
                 m_cachedText += QLatin1String(" : ") + targetType->toString();
             }
         }
         break;
         default:
             QString typeStr = type->toString();
             if (!typeStr.isEmpty()) {
                 m_cachedText += QLatin1String(" : ") + typeStr;
             }
         }
     }
 
 
     //these two don't seem to be hit
     if (decl->isAutoDeclaration()) {
         m_cachedText = QLatin1String("Implicit: ") + m_cachedText;
     }
     if (decl->isAnonymous()) {
         m_cachedText = QLatin1String("<anonymous>") + m_cachedText;
     }
 
     if (DUContext* ctx = decl->internalContext()) {
         appendContext(ctx, decl->topContext());
     }
     if (m_cachedText.isEmpty()) {
         m_cachedText = i18nc("An anonymous declaration (class, function, etc.)", "<anonymous>");
     }
 }
 
 std::unique_ptr<OutlineNode> OutlineNode::dummyNode()
 {
     return std::unique_ptr<OutlineNode>(new OutlineNode(QStringLiteral("<dummy node>"), nullptr));
 }
 
 std::unique_ptr<OutlineNode> OutlineNode::fromTopContext(TopDUContext* ctx)
 {
     auto result = dummyNode();
     result->appendContext(ctx, ctx);
     return result;
 }
 
 void OutlineNode::appendContext(DUContext* ctx, TopDUContext* top)
 {
     // qDebug() << ctx->scopeIdentifier().toString() << "context type=" << ctx->type();
     foreach (Declaration* childDecl, ctx->localDeclarations(top)) {
         if (childDecl) {
             m_children.emplace_back(childDecl, this);
         }
     }
     bool certainlyRequiresSorting = false;
     foreach (DUContext* childContext, ctx->childContexts()) {
         if (childContext->owner()) {
             // if there is a onwner, this will already have been handled by the loop above
             // TODO: is this always true? With my testing so far it seems to be
             // qDebug() << childContext->scopeIdentifier(true).toString()
             //        << " has an owner declaration: " << childContext->owner()->toString() << "-> skip";
             continue;
         }
         QVector<Declaration*> decls = childContext->localDeclarations(top);
         if (decls.isEmpty()) {
             continue;
         }
         // we now know that we will have o sort since we appended a node in the wrong order
         certainlyRequiresSorting = true;
         QString ctxName = childContext->scopeIdentifier(true).toString();
         // if child context is a template context or if name is empty append to current list,
         // otherwise create a new context node
         if (childContext->type() == DUContext::Template || ctxName.isEmpty()) {
             //append all subcontexts to this node
             appendContext(childContext, top);
         } else {
             // context without matching declaration, for example the definition of
             // "class Foo::Bar if it was forward declared in a namespace before:
             // namespace Foo { class Bar; }
             // class Foo::Bar { ... };
             // TODO: icon and location for the namespace
             if (childContext->type() == DUContext::ContextType::Helper) {
                 // This context could be for a definition of an existing class method.
                 // If we don't merge all those context end up with a tree like this:
                 //  +-+- FooClass
                 //  | \-- method1()
                 //  +-+- FooClass
                 //  | \-- method2()
                 //  \ OtherStuff
                 auto it = std::find_if(m_children.begin(), m_children.end(), [childContext](const OutlineNode& node) {
                     if (DUContext* ctx = dynamic_cast<DUContext*>(node.duChainObject())) {
                         return ctx->equalScopeIdentifier(childContext);
                     }
                     return false;
                 });
                 if (it != m_children.end()) {
                     it->appendContext(childContext, top);
                 }
                 else {
                     // TODO: get the correct icon for the context
                     m_children.emplace_back(childContext, ctxName, this);
                 }
             } else {
                 // just add the context
                 m_children.emplace_back(childContext, ctxName, this);
             }
         }
     }
     // we now need to sort since sometimes the elements from ctx->localDeclarations(top)
     // are not in the order they appear in the source. Additionally, if we had any child
     // contexts that were added, they will be at the end of the list
     // and need to be moved to the correct location. In that case certainlyRequiresSorting
     // will be true and we can pass it to sortByLocation() to skip the std::is_sorted() call
     sortByLocation(certainlyRequiresSorting);
 }
 
 void OutlineNode::sortByLocation(bool requiresSorting)
 {
 
     if (m_children.size() <= 1) {
         return;
     }
     // TODO: does it make sense to cache m_declOrContext->range().start?
     // adds 8 bytes to each node, but save a lot of pointer lookups when sorting
     // qDebug("sorting children of %s (%p) by location", qPrintable(m_cachedText), this);
     auto compare = [](const OutlineNode& n1, const OutlineNode& n2) -> bool {
         // nodes without decl always go at the end
         if (!n1.m_declOrContext) {
             return false;
         } else if (!n2.m_declOrContext) {
             return true;
         }
         return n1.m_declOrContext->range().start < n2.m_declOrContext->range().start;
     };
     // since most nodes will be correctly sorted we check that before calling std::sort().
     // This saves a lot of move ctor/assingnment calls in the common case.
     // If we appended a context without a Declaration* we know that it will be unsorted
     // so we can pass requiresSorting = true to skip the useless std::is_sorted() call.
     // uncomment the following qDebug() lines to see whether this optimization really makes sense
     if (requiresSorting || !std::is_sorted(m_children.begin(), m_children.end(), compare)) {
         // qDebug("Need to sort node %s(%p)", qPrintable(m_cachedText), this);
         std::sort(m_children.begin(), m_children.end(), compare);
     } else {
         // qDebug("Node %s(%p) was sorted!", qPrintable(m_cachedText), this);
     }
 }
 
 OutlineNode::~OutlineNode()
 {
 }
diff --git a/plugins/problemreporter/problemreportermodel.cpp b/plugins/problemreporter/problemreportermodel.cpp
index e97a9bd178..1236924819 100644
--- a/plugins/problemreporter/problemreportermodel.cpp
+++ b/plugins/problemreporter/problemreportermodel.cpp
@@ -1,169 +1,169 @@
 /*
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "problemreportermodel.h"
 
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/problem.h>
 #include <language/duchain/duchainutils.h>
 #include <language/assistant/staticassistantsmanager.h>
 
 #include <QThread>
 #include <QTimer>
 
 #include <serialization/indexedstring.h>
 
 #include <shell/watcheddocumentset.h>
 #include <shell/filteredproblemstore.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/idocument.h>
 
 using namespace KDevelop;
 
 const int ProblemReporterModel::MinTimeout = 1000;
 const int ProblemReporterModel::MaxTimeout = 5000;
 
 ProblemReporterModel::ProblemReporterModel(QObject* parent)
     : ProblemModel(parent, new FilteredProblemStore())
 {
     setFeatures(CanDoFullUpdate | CanShowImports | ScopeFilter | SeverityFilter | ShowSource);
 
     m_minTimer = new QTimer(this);
     m_minTimer->setInterval(MinTimeout);
     m_minTimer->setSingleShot(true);
     connect(m_minTimer, &QTimer::timeout, this, &ProblemReporterModel::timerExpired);
     m_maxTimer = new QTimer(this);
     m_maxTimer->setInterval(MaxTimeout);
     m_maxTimer->setSingleShot(true);
     connect(m_maxTimer, &QTimer::timeout, this, &ProblemReporterModel::timerExpired);
     connect(store(), &FilteredProblemStore::changed, this, &ProblemReporterModel::onProblemsChanged);
     connect(ICore::self()->languageController()->staticAssistantsManager(), &StaticAssistantsManager::problemsChanged,
             this, &ProblemReporterModel::onProblemsChanged);
 }
 
 ProblemReporterModel::~ProblemReporterModel()
 {
 }
 
 QVector<KDevelop::IProblem::Ptr> ProblemReporterModel::problems(const QSet<KDevelop::IndexedString>& docs) const
 {
     QVector<IProblem::Ptr> result;
     DUChainReadLocker lock;
 
     for (const IndexedString& doc : docs) {
         if (doc.isEmpty())
             continue;
 
         TopDUContext* ctx = DUChain::self()->chainForDocument(doc);
         if (!ctx)
             continue;
 
         const auto allProblems = DUChainUtils::allProblemsForContext(ctx);
         result.reserve(result.size() + allProblems.size());
         for (const ProblemPointer& p : allProblems) {
             result.append(p);
         }
     }
 
     return result;
 }
 
 void ProblemReporterModel::forceFullUpdate()
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     QSet<IndexedString> documents = store()->documents()->get();
     if (showImports())
-        documents += store()->documents()->getImports();
+        documents += store()->documents()->imports();
 
     DUChainReadLocker lock(DUChain::lock());
     foreach (const IndexedString& document, documents) {
         if (document.isEmpty())
             continue;
 
         TopDUContext::Features updateType = TopDUContext::ForceUpdate;
         if (documents.size() == 1)
             updateType = TopDUContext::ForceUpdateRecursive;
         DUChain::self()->updateContextForUrl(
             document,
             (TopDUContext::Features)(updateType | TopDUContext::VisibleDeclarationsAndContexts));
     }
 }
 
 void ProblemReporterModel::onProblemsChanged()
 {
     rebuildProblemList();
 }
 
 void ProblemReporterModel::timerExpired()
 {
     m_minTimer->stop();
     m_maxTimer->stop();
     rebuildProblemList();
 }
 
 void ProblemReporterModel::setCurrentDocument(KDevelop::IDocument* doc)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     beginResetModel();
 
     /// Will trigger signal changed() if problems change
     store()->setCurrentDocument(IndexedString(doc->url()));
     endResetModel();
 }
 
 void ProblemReporterModel::problemsUpdated(const KDevelop::IndexedString& url)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     // skip update for urls outside current scope
     if (!store()->documents()->get().contains(url) &&
-        !(showImports() && store()->documents()->getImports().contains(url)))
+        !(showImports() && store()->documents()->imports().contains(url)))
         return;
 
     /// m_minTimer will expire in MinTimeout unless some other parsing job finishes in this period.
     m_minTimer->start();
     /// m_maxTimer will expire unconditionally in MaxTimeout
     if (!m_maxTimer->isActive()) {
         m_maxTimer->start();
     }
 }
 
 void ProblemReporterModel::rebuildProblemList()
 {
     /// No locking here, because it may be called from an already locked context
     beginResetModel();
 
     QVector<IProblem::Ptr> allProblems = problems(store()->documents()->get());
 
     if (showImports())
-        allProblems += problems(store()->documents()->getImports());
+        allProblems += problems(store()->documents()->imports());
 
     store()->setProblems(allProblems);
 
     endResetModel();
 }