diff --git a/codecompletion/context.cpp b/codecompletion/context.cpp
index dafad2e26d..1d52021ad8 100644
--- a/codecompletion/context.cpp
+++ b/codecompletion/context.cpp
@@ -1,875 +1,892 @@
 /*
  * This file is part of KDevelop
  * Copyright 2014 Milian Wolff <mail@milianw.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "context.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/duchainutils.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/typealiastype.h>
 #include <language/interfaces/iastcontainer.h>
 #include <language/codecompletion/codecompletionitem.h>
 #include <language/codecompletion/codecompletionmodel.h>
 #include <language/codecompletion/normaldeclarationcompletionitem.h>
 
 #include "../util/clangdebug.h"
 #include "../util/clangtypes.h"
 #include "../duchain/parsesession.h"
 #include "../duchain/navigationwidget.h"
 #include "../clangsettings/clangsettingsmanager.h"
 
 #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)
     {
     }
 
     virtual ~CompletionItem() = 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 {};
     }
 
 protected:
     QString m_display;
     QString m_prefix;
 };
 
 class OverrideItem : public CompletionItem<CompletionTreeItem>
 {
 public:
     OverrideItem(const QString& nameAndParams, const QString& returnType)
         : CompletionItem<KDevelop::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, QLatin1String("virtual ") + m_returnType + QLatin1Char(' ') + m_display);
     }
 
 private:
     QString m_returnType;
 };
 
 class ImplementsItem : public CompletionItem<CompletionTreeItem>
 {
 public:
     ImplementsItem(const FuncImplementInfo& item)
         : CompletionItem<KDevelop::CompletionTreeItem>(
               item.prototype,
               i18n("Implement %1", item.isConstructor ? QStringLiteral("<constructor>") :
                                    item.isDestructor ? QStringLiteral("<destructor>") : item.returnType)
           )
         , m_item(item)
     {
     }
 
     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("CTsuppliers"));
                 return icon;
             }
         }
         return CompletionItem<CompletionTreeItem>::data(index, role, model);
     }
 
     void execute(KTextEditor::View* view, const KTextEditor::Range& word) override
     {
         QString replacement = m_item.templatePrefix;
         if (!m_item.isDestructor && !m_item.isConstructor) {
             replacement += m_item.returnType + QLatin1Char(' ');
         }
         replacement += m_item.prototype + QLatin1String("\n{\n}\n");
         view->document()->replaceText(word, replacement);
     }
 
 private:
     FuncImplementInfo m_item;
 };
 
 /**
  * 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()) {
             repl += QLatin1String("()");
             view->document()->replaceText(word, repl);
             auto f = m_declaration->type<FunctionType>();
             if (f && f->indexedArgumentsSize()) {
                 view->setCursorPosition(word.start() + KTextEditor::Cursor(0, repl.size() - 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);
     }
 
     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;
     }
 
 private:
     int m_matchQuality = 0;
     QString m_replacement;
 };
 
 /**
  * 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;
         }
         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
     CXToken* tokens = nullptr;
     unsigned int nTokens = 0;
     clang_tokenize(unit, range, &tokens, &nTokens);
     for (unsigned int i = 0; i < nTokens; ++i) {
         CXToken token = tokens[i];
         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, QLatin1String("..."));
     }
     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;
 }
 
 void addEnumItems(Declaration* declaration, QHash<QualifiedIdentifier, Declaration*>& declarationsCache);
 
 /// Add declarations from namespace into @p declarationsCache
 void addNamespaceItems(Declaration* declaration, QHash<QualifiedIdentifier, Declaration*>& declarationsCache)
 {
     if (declaration->kind() != Declaration::Namespace || !declaration->internalContext()) {
         return;
     }
 
     const auto namespaceDeclarations = declaration->internalContext()->localDeclarations();
     for (const auto& nd : namespaceDeclarations) {
         declarationsCache.insert(nd->qualifiedIdentifier(), nd);
         addEnumItems(nd, declarationsCache);
     }
 }
 
 /// Add enumerators into @p declarationsCache
 void addEnumItems(Declaration* declaration, QHash<QualifiedIdentifier, Declaration*>& declarationsCache)
 {
     if (declaration->kind() != Declaration::Type || !declaration->internalContext()) {
         return;
     }
 
     const auto ictx = declaration->internalContext();
     if (ictx->type() == DUContext::Enum) {
         for (const auto enumerator : ictx->localDeclarations()) {
             declarationsCache.insert(enumerator->qualifiedIdentifier(), enumerator);
         }
     }
 }
 
 QMultiHash<QualifiedIdentifier, Declaration*> generateCache(const DUContextPointer& ctx, const CursorInRevision& position)
 {
     const auto allDeclarationsList = ctx->allDeclarations(position, ctx->topContext());
     QMultiHash<QualifiedIdentifier, Declaration*> declarationsHash;
 
     for (const auto& declaration : allDeclarationsList) {
         // We store function-local declarations with qid like: "function::declaration", but completion items provided by Clang have qid like: "declaration", so we use id here instead.
         declarationsHash.insert(declaration.second ? declaration.first->qualifiedIdentifier() : QualifiedIdentifier(declaration.first->identifier()), declaration.first);
 
         // Intentionally not recurse into nested namespaces and inner class contexts as the findDeclarations call is much cheaper.
         addNamespaceItems(declaration.first, declarationsHash);
         addEnumItems(declaration.first, declarationsHash);
     }
 
     return declarationsHash;
 }
 
 Declaration* findDeclaration(const QualifiedIdentifier& qid, const DUContextPointer& ctx, const CursorInRevision& position, const QMultiHash<QualifiedIdentifier, Declaration*>& declarationsCache, QSet<Declaration*>& handled)
 {
     auto i = declarationsCache.find(qid);
     while (i != declarationsCache.end() && i.key() == qid) {
         auto declaration = i.value();
         if (!handled.contains(declaration)) {
             handled.insert(declaration);
             return declaration;
         }
         ++i;
     }
 
     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)
+Declaration* classDeclarationForContext(const DUContextPointer& context, const CursorInRevision& position, const QMultiHash<QualifiedIdentifier, Declaration*>& declarationsCache)
 {
     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, declarationsCache, tmp);
+
+                if (decl && decl->internalContext() && decl->internalContext()->type() == DUContext::Class) {
+                    parent = decl->internalContext();
+                    break;
+                }
+            }
+        }
         parent = parent->parentContext();
     }
 
     return parent ? parent->owner() : nullptr;
 }
 
 }
 
 ClangCodeCompletionContext::ClangCodeCompletionContext(const DUContextPointer& context,
                                                        const ParseSessionData::Ptr& sessionData,
                                                        const QUrl& url,
                                                        const KTextEditor::Cursor& position,
                                                        const QString& text
                                                       )
     : CodeCompletionContext(context, text, CursorInRevision::castFromSimpleCursor(position), 0)
     , m_results(nullptr, clang_disposeCodeCompleteResults)
     , m_parseSessionData(sessionData)
 {
     const QByteArray file = url.toLocalFile().toUtf8();
     ParseSession session(m_parseSessionData);
     {
         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() + 1; // + \0-byte
 
         m_results.reset(clang_codeCompleteAt(session.unit(), file.constData(),
                         position.line() + 1, position.column() + 1,
                         content.isEmpty() ? nullptr : &unsaved, content.isEmpty() ? 0 : 1,
                         completeOptions));
 
         if (!m_results) {
             qCWarning(KDEV_CLANG) << "Something went wrong during 'clang_codeCompleteAt' for file" << file;
             return;
         }
 
         auto addMacros = ClangSettingsManager::self()->codeCompletionSettings().macros;
         if (!addMacros) {
             m_filters |= NoMacros;
         }
     }
 
     // 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));
     const auto declarationsCache = generateCache(ctx, 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;
 
     QSet<Declaration*> handled;
 
     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];
 
         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 || !classDeclarationForContext(ctx))) {
+        // If ctx is/inside the Class context, this represents that context.
+        auto currentClassContext = classDeclarationForContext(ctx, m_position, declarationsCache);
+        if (availability == CXAvailability_NotAccessible && (!isDeclaration || !currentClassContext)) {
             continue;
         }
 
         const uint chunks = clang_getNumCompletionChunks(result.CompletionString);
 
         // 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 display string we use in the simple code completion items, including the function signature.
         QString display;
         // the return type of a function e.g.
         QString resultType;
         // the replacement text when an item gets executed
         QString replacement;
         //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
         for (uint j = 0; j < chunks; ++j) {
             const auto kind = clang_getCompletionChunkKind(result.CompletionString, j);
             if (kind == CXCompletionChunk_CurrentParameter || kind == CXCompletionChunk_Optional) {
                 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()){
                 break;
             }
 
             const QString string = ClangString(clang_getCompletionChunkText(result.CompletionString, j)).toString();
             switch (kind) {
                 case CXCompletionChunk_TypedText:
                     display += string;
                     typed = string;
                     replacement = string;
                     break;
                 case CXCompletionChunk_ResultType:
                     resultType = string;
                     continue;
                 case CXCompletionChunk_Placeholder:
                     //TODO:consider KTextEditor::TemplateInterface possibility
                     //replacement += "/*" + string + "*/";
                     if (signatureState == Inside) {
                         display += string;
                     }
                     continue;
                 case CXCompletionChunk_LeftParen:
                     if (signatureState == Before && !parenDepth) {
                         signatureState = Inside;
                     }
                     parenDepth++;
                     break;
                 case CXCompletionChunk_RightParen:
                     --parenDepth;
                     if (signatureState == Inside && !parenDepth) {
                         display += QLatin1Char(')');
                         signatureState = After;
                     }
                     break;
                 default:
                     break;
             }
             //replacement += string;
             if (signatureState == Inside) {
                 display += string;
             }
         }
 
         if(typed.isEmpty()){
             continue;
         }
 
         // ellide text to the right for overly long result types (templates especially)
         elideStringRight(resultType, MAX_RETURN_TYPE_STRING_LENGTH);
 
         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;
             }
 
             auto found = findDeclaration(qid, ctx, m_position, declarationsCache, 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()));
-                        auto currentClassContext = classDeclarationForContext(ctx);
+                        auto declarationClassContext = classDeclarationForContext(DUContextPointer(found->context()), m_position, declarationsCache);
 
                         uint steps = 10;
                         auto inheriters = DUChainUtils::getInheriters(declarationClassContext, steps);
                         if(!inheriters.contains(currentClassContext)){
                             continue;
                         }
                     } else {
                         continue;
                     }
                 }
 
                 auto declarationItem = new DeclarationItem(found, display, 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
                 if (bestMatch && !found->indexedIdentifier().identifier().toString().startsWith(QLatin1String("__")) ) {
                     const int matchQuality = codeCompletionPriorityToMatchQuality(completionPriority);
                     declarationItem->setMatchQuality(matchQuality);
                 } else {
                     declarationItem->setInheritanceDepth(completionPriority);
                 }
 
                 item = declarationItem;
             } 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;
                 item = CompletionTreeItemPointer(new SimpleItem(display, resultType, replacement));
             }
 
             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
             static const QIcon icon = QIcon::fromTheme(QStringLiteral("code-macro"));
             auto item = CompletionTreeItemPointer(new SimpleItem(display, resultType, replacement, icon));
             macros.append(item);
         } else if (result.CursorKind == CXCursor_NotImplemented) {
             auto item = CompletionTreeItemPointer(new SimpleItem(display, resultType, replacement));
             builtin.append(item);
         }
     }
 
     if (abort) {
         return {};
     }
 
     addImplementationHelperItems();
     addOverwritableItems();
 
     eventuallyAddGroup(i18n("Special"), 700, specialItems);
     eventuallyAddGroup(i18n("Macros"), 900, macros);
     eventuallyAddGroup(i18n("Builtin"), 800, builtin);
     return items;
 }
 
 void ClangCodeCompletionContext::eventuallyAddGroup(const QString& name, int priority,
                                                     const QList<CompletionTreeItemPointer>& items)
 {
     if (items.isEmpty()) {
         return;
     }
 
     KDevelop::CompletionCustomGroupNode* node = new KDevelop::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;
     for (int i = 0; i < overrideList.count(); i++) {
         FuncOverrideInfo info = overrideList.at(i);
         QString nameAndParams = info.name + QLatin1Char('(') + info.params.join(QLatin1String(", ")) + QLatin1Char(')');
         if(info.isConst)
             nameAndParams = nameAndParams + QLatin1String(" const");
         if(info.isVirtual)
             nameAndParams = nameAndParams + QLatin1String(" = 0");
         overrides << CompletionTreeItemPointer(new OverrideItem(nameAndParams, info.returnType));
     }
     eventuallyAddGroup(i18n("Virtual Override"), 0, overrides);
 }
 
 void ClangCodeCompletionContext::addImplementationHelperItems()
 {
     auto implementsList = m_completionHelper.implements();
     if (implementsList.isEmpty()) {
         return;
     }
 
     QList<CompletionTreeItemPointer> implements;
     foreach(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;
 }
diff --git a/duchain/builder.cpp b/duchain/builder.cpp
index b3ed590a5f..f0b17f67e0 100644
--- a/duchain/builder.cpp
+++ b/duchain/builder.cpp
@@ -1,1300 +1,1300 @@
 /*
  *    This file is part of KDevelop
  *
  *    Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
  *    Copyright 2015 Milian Wolff <mail@milianw.de>
  *
  *    This library is free software; you can redistribute it and/or
  *    modify it under the terms of the GNU Library General Public
  *    License as published by the Free Software Foundation; either
  *    version 2 of the License, or (at your option) any later version.
  *
  *    This library is distributed in the hope that it will be useful,
  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *    Library General Public License for more details.
  *
  *    You should have received a copy of the GNU Library General Public License
  *    along with this library; see the file COPYING.LIB.  If not, write to
  *    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *    Boston, MA 02110-1301, USA.
  */
 
 #include "builder.h"
 
 #include "util/clangdebug.h"
 
 #include "templatehelpers.h"
 #include "cursorkindtraits.h"
 #include "clangducontext.h"
 #include "macrodefinition.h"
 #include "util/clangdebug.h"
 #include "util/clangutils.h"
 #include "util/clangtypes.h"
 
 #include <util/pushvalue.h>
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/stringhelpers.h>
 
 #include <language/duchain/types/pointertype.h>
 #include <language/duchain/types/arraytype.h>
 #include <language/duchain/types/referencetype.h>
 #include <language/duchain/types/functiontype.h>
 #include <language/duchain/types/structuretype.h>
 #include <language/duchain/types/enumerationtype.h>
 #include <language/duchain/types/enumeratortype.h>
 #include <language/duchain/types/typealiastype.h>
 #include <language/duchain/types/indexedtype.h>
 
 #if CINDEX_VERSION_MINOR >= 25
 #include <clang-c/Documentation.h>
 #endif
 
 #include <unordered_map>
 #include <typeinfo>
 
 
 /// Turn on for debugging the declaration building
 #define IF_DEBUG(x)
 
 namespace {
 
 // TODO: this is ugly, can we find a better alternative?
 static bool s_jsonTestRun = false;
 
 //BEGIN helpers
 /**
  * Find the cursor that cursor @p cursor references
  *
  * First tries to get the referenced cursor via clang_getCursorReferenced,
  * and if that fails, tries to get them via clang_getOverloadedDecl
  * (which returns the referenced cursor for CXCursor_OverloadedDeclRef, for example)
  *
  * @return Valid cursor on success, else null cursor
  */
 CXCursor referencedCursor(CXCursor cursor)
 {
     auto referenced = clang_getCursorReferenced(cursor);
     if (!clang_equalCursors(cursor, referenced)) {
         return referenced;
     }
 
     // get the first result for now
     referenced = clang_getOverloadedDecl(cursor, 0);
     if (!clang_Cursor_isNull(referenced)) {
         return referenced;
     }
     return clang_getNullCursor();
 }
 
 Identifier makeId(CXCursor cursor)
 {
     return Identifier(ClangString(clang_getCursorSpelling(cursor)).toIndexed());
 }
 
 QByteArray makeComment(CXComment comment)
 {
     if (Q_UNLIKELY(s_jsonTestRun)) {
         auto kind = clang_Comment_getKind(comment);
         if (kind == CXComment_Text)
             return ClangString(clang_TextComment_getText(comment)).toByteArray();
 
         QByteArray text;
         int numChildren = clang_Comment_getNumChildren(comment);
         for (int i = 0; i < numChildren; ++i)
             text += makeComment(clang_Comment_getChild(comment, i));
         return text;
     }
 
     return ClangString(clang_FullComment_getAsHTML(comment)).toByteArray();
 }
 
 AbstractType* createDelayedType(CXType type)
 {
     auto t = new DelayedType;
 
     // TODO: Fix clang_getTypeSpelling not to prepend type modifiers for auto types
     QString typeName = ClangString(clang_getTypeSpelling(type)).toString();
     typeName.remove(QStringLiteral("const "));
     typeName.remove(QStringLiteral("volatile "));
 
     t->setIdentifier(IndexedTypeIdentifier(typeName));
     return t;
 }
 
 void contextImportDecl(DUContext* context, const DeclarationPointer& decl)
 {
     auto top = context->topContext();
     if (auto import = decl->logicalInternalContext(top)) {
         context->addImportedParentContext(import);
         context->topContext()->updateImportsCache();
     }
 }
 
 //END helpers
 
 CXChildVisitResult visitCursor(CXCursor cursor, CXCursor parent, CXClientData data);
 
 //BEGIN IdType
 template<CXCursorKind CK, class Enable = void>
 struct IdType;
 
 template<CXCursorKind CK>
 struct IdType<CK, typename std::enable_if<CursorKindTraits::isClass(CK)>::type>
 {
     typedef StructureType Type;
 };
 
 template<CXCursorKind CK>
 struct IdType<CK, typename std::enable_if<CK == CXCursor_TypedefDecl>::type>
 {
     typedef TypeAliasType Type;
 };
 
 template<CXCursorKind CK>
 struct IdType<CK, typename std::enable_if<CK == CXCursor_TypeAliasDecl>::type>
 {
     typedef TypeAliasType Type;
 };
 
 template<CXCursorKind CK>
 struct IdType<CK, typename std::enable_if<CK == CXCursor_EnumDecl>::type>
 {
     typedef EnumerationType Type;
 };
 
 template<CXCursorKind CK>
 struct IdType<CK, typename std::enable_if<CK == CXCursor_EnumConstantDecl>::type>
 {
     typedef EnumeratorType Type;
 };
 //END IdType
 
 //BEGIN DeclType
 template<CXCursorKind CK, bool isDefinition, bool isClassMember, class Enable = void>
 struct DeclType;
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevDeclaration(CK, isInClass)>::type>
 {
     typedef Declaration Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CK == CXCursor_MacroDefinition>::type>
 {
     typedef MacroDefinition Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevForwardDeclaration(CK, isDefinition)>::type>
 {
     typedef ForwardDeclaration Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevClassDeclaration(CK, isDefinition)>::type>
 {
     typedef ClassDeclaration Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevClassFunctionDeclaration(CK, isInClass)>::type>
 {
     typedef ClassFunctionDeclaration Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevFunctionDeclaration(CK, isDefinition, isInClass)>::type>
 {
     typedef FunctionDeclaration Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevFunctionDefinition(CK, isDefinition, isInClass)>::type>
 {
     typedef FunctionDefinition Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevNamespaceAliasDeclaration(CK, isDefinition)>::type>
 {
     typedef NamespaceAliasDeclaration Type;
 };
 
 template<CXCursorKind CK, bool isDefinition, bool isInClass>
 struct DeclType<CK, isDefinition, isInClass,
     typename std::enable_if<CursorKindTraits::isKDevClassMemberDeclaration(CK, isInClass)>::type>
 {
     typedef ClassMemberDeclaration Type;
 };
 //END DeclType
 
 //BEGIN CurrentContext
 struct CurrentContext
 {
     CurrentContext(DUContext* context)
         : context(context)
     {
         DUChainReadLocker lock;
         previousChildContexts = context->childContexts();
         previousChildDeclarations = context->localDeclarations();
     }
 
     ~CurrentContext()
     {
         DUChainWriteLocker lock;
         qDeleteAll(previousChildContexts);
         qDeleteAll(previousChildDeclarations);
     }
 
     DUContext* context;
     // when updatig, this contains child contexts of the current parent context
     QVector<DUContext*> previousChildContexts;
     // when updatig, this contains child declarations of the current parent context
     QVector<Declaration*> previousChildDeclarations;
 };
 //END CurrentContext
 
 //BEGIN Visitor
 struct Visitor
 {
     explicit Visitor(CXTranslationUnit tu, CXFile file,
                      const IncludeFileContexts& includes, const bool update);
 
     AbstractType *makeType(CXType type, CXCursor parent);
     AbstractType::Ptr makeAbsType(CXType type, CXCursor parent)
     {
         return AbstractType::Ptr(makeType(type, parent));
     }
 
 //BEGIN dispatch*
     template<CXCursorKind CK,
       Decision IsInClass = CursorKindTraits::isInClass(CK),
       EnableIf<IsInClass == Decision::Maybe> = dummy>
     CXChildVisitResult dispatchCursor(CXCursor cursor, CXCursor parent);
 
     template<CXCursorKind CK,
         Decision IsInClass = CursorKindTraits::isInClass(CK),
         Decision IsDefinition = CursorKindTraits::isDefinition(CK),
         EnableIf<IsDefinition == Decision::Maybe && IsInClass != Decision::Maybe> = dummy>
     CXChildVisitResult dispatchCursor(CXCursor cursor, CXCursor parent);
 
     template<CXCursorKind CK,
         Decision IsInClass = CursorKindTraits::isInClass(CK),
         Decision IsDefinition = CursorKindTraits::isDefinition(CK),
         EnableIf<IsInClass != Decision::Maybe && IsDefinition != Decision::Maybe> = dummy>
     CXChildVisitResult dispatchCursor(CXCursor cursor, CXCursor parent);
 
     template<CXTypeKind TK>
     AbstractType *dispatchType(CXType type, CXCursor cursor)
     {
         IF_DEBUG(clangDebug() << "TK:" << type.kind;)
 
         auto kdevType = createType<TK>(type, cursor);
         if (kdevType) {
             setTypeModifiers<TK>(type, kdevType);
         }
         return kdevType;
     }
 //BEGIN dispatch*
 
 //BEGIN build*
     template<CXCursorKind CK, class DeclType, bool hasContext>
     CXChildVisitResult buildDeclaration(CXCursor cursor);
 
     CXChildVisitResult buildUse(CXCursor cursor);
     CXChildVisitResult buildMacroExpansion(CXCursor cursor);
     CXChildVisitResult buildCompoundStatement(CXCursor cursor);
     CXChildVisitResult buildCXXBaseSpecifier(CXCursor cursor);
     CXChildVisitResult buildParmDecl(CXCursor cursor);
 
 //END build*
 
 //BEGIN create*
     template<CXCursorKind CK, class DeclType>
     DeclType* createDeclarationCommon(CXCursor cursor, const Identifier& id)
     {
         auto range = ClangHelpers::cursorSpellingNameRange(cursor, id);
 
         // check if cursor is inside a macro expansion
         auto clangRange = clang_Cursor_getSpellingNameRange(cursor, 0, 0);
         unsigned int expansionLocOffset;
         const auto spellingLocation = clang_getRangeStart(clangRange);
         clang_getExpansionLocation(spellingLocation, nullptr, nullptr, nullptr, &expansionLocOffset);
         if (m_macroExpansionLocations.contains(expansionLocOffset)) {
             unsigned int spellingLocOffset;
             clang_getSpellingLocation(spellingLocation, nullptr, nullptr, nullptr, &spellingLocOffset);
             // Set empty ranges for declarations inside macro expansion
             if (spellingLocOffset == expansionLocOffset) {
                 range.end = range.start;
             }
         }
 
         if (m_update) {
             const IndexedIdentifier indexedId(id);
             DUChainWriteLocker lock;
             auto it = m_parentContext->previousChildDeclarations.begin();
             while (it != m_parentContext->previousChildDeclarations.end()) {
                 auto decl = dynamic_cast<DeclType*>(*it);
                 if (decl && decl->indexedIdentifier() == indexedId) {
                     decl->setRange(range);
                     setDeclData<CK>(cursor, decl);
                     m_cursorToDeclarationCache[clang_hashCursor(cursor)] = decl;
                     m_parentContext->previousChildDeclarations.erase(it);
                     return decl;
                 }
                 ++it;
             }
         }
         auto decl = new DeclType(range, nullptr);
         decl->setIdentifier(id);
         m_cursorToDeclarationCache[clang_hashCursor(cursor)] = decl;
         setDeclData<CK>(cursor, decl);
         {
             DUChainWriteLocker lock;
             decl->setContext(m_parentContext->context);
         }
         return decl;
     }
 
     template<CXCursorKind CK, class DeclType>
     Declaration* createDeclaration(CXCursor cursor, const Identifier& id, DUContext *context)
     {
         auto decl = createDeclarationCommon<CK, DeclType>(cursor, id);
         auto type = createType<CK>(cursor);
 
         DUChainWriteLocker lock;
         if (context)
             decl->setInternalContext(context);
         setDeclType<CK>(decl, type);
         setDeclInCtxtData<CK>(cursor, decl);
         return decl;
     }
 
     template<CXCursorKind CK, DUContext::ContextType Type>
     DUContext* createContext(CXCursor cursor, const QualifiedIdentifier& scopeId = {})
     {
         // wtf: why is the DUContext API requesting a QID when it needs a plain Id?!
         // see: testNamespace
         auto range = ClangRange(clang_getCursorExtent(cursor)).toRangeInRevision();
         DUChainWriteLocker lock;
         if (m_update) {
             const IndexedQualifiedIdentifier indexedScopeId(scopeId);
             auto it = m_parentContext->previousChildContexts.begin();
             while (it != m_parentContext->previousChildContexts.end()) {
                 auto ctx = *it;
                 if (ctx->type() == Type && ctx->indexedLocalScopeIdentifier() == indexedScopeId) {
                     ctx->setRange(range);
                     m_parentContext->previousChildContexts.erase(it);
                     return ctx;
                 }
                 ++it;
             }
         }
         //TODO: (..type, id..) constructor for DUContext?
         auto context = new ClangNormalDUContext(range, m_parentContext->context);
         context->setType(Type);
         context->setLocalScopeIdentifier(scopeId);
         if (Type == DUContext::Other || Type == DUContext::Function)
             context->setInSymbolTable(false);
 
         if (CK == CXCursor_CXXMethod || CursorKindTraits::isClass(CK)) {
             CXCursor semParent = clang_getCursorSemanticParent(cursor);
             if (!clang_Cursor_isNull(semParent)) {
                 auto semParentDecl = findDeclaration(semParent);
                 if (semParentDecl) {
                     contextImportDecl(context, semParentDecl);
                 }
             }
         }
         return context;
     }
 
     template<CXTypeKind TK, EnableIf<CursorKindTraits::integralType(TK) != -1> = dummy>
     AbstractType *createType(CXType, CXCursor)
     {
         // TODO: would be nice to instantiate a ConstantIntegralType here and set a value if possible
         // but unfortunately libclang doesn't offer API to that
         // also see http://marc.info/?l=cfe-commits&m=131609142917881&w=2
         return new IntegralType(CursorKindTraits::integralType(TK));
     }
 
     template<CXTypeKind TK, EnableIf<CursorKindTraits::isPointerType(TK)> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         auto ptr = new PointerType;
         ptr->setBaseType(makeAbsType(clang_getPointeeType(type), parent));
         return ptr;
     }
 
     template<CXTypeKind TK, EnableIf<CursorKindTraits::isArrayType(TK)> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         auto arr = new ArrayType;
         arr->setDimension((TK == CXType_IncompleteArray || TK == CXType_VariableArray || TK == CXType_DependentSizedArray) ? 0 : clang_getArraySize(type));
         arr->setElementType(makeAbsType(clang_getArrayElementType(type), parent));
         return arr;
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_RValueReference || TK == CXType_LValueReference> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         auto ref = new ReferenceType;
         ref->setIsRValue(type.kind == CXType_RValueReference);
         ref->setBaseType(makeAbsType(clang_getPointeeType(type), parent));
         return ref;
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_FunctionProto> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         auto func = new FunctionType;
         func->setReturnType(makeAbsType(clang_getResultType(type), parent));
         const int numArgs = clang_getNumArgTypes(type);
         for (int i = 0; i < numArgs; ++i) {
             func->addArgument(makeAbsType(clang_getArgType(type, i), parent));
         }
 
         if (clang_isFunctionTypeVariadic(type)) {
             auto type = new DelayedType;
             static const auto id = IndexedTypeIdentifier(QStringLiteral("..."));
             type->setIdentifier(id);
             type->setKind(DelayedType::Unresolved);
             func->addArgument(AbstractType::Ptr(type));
         }
 
         return func;
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_Record || TK == CXType_ObjCInterface || TK == CXType_ObjCClass> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         DeclarationPointer decl = findDeclaration(clang_getTypeDeclaration(type));
         DUChainReadLocker lock;
 
         if (!decl) {
             // probably a forward-declared type
             decl = ClangHelpers::findForwardDeclaration(type, m_parentContext->context, parent);
         }
 
         auto t = new StructureType;
         t->setDeclaration(decl.data());
         return t;
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_Enum> = dummy>
     AbstractType *createType(CXType type, CXCursor)
     {
         auto t = new EnumerationType;
         setIdTypeDecl(clang_getTypeDeclaration(type), t);
         return t;
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_Typedef> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         auto t = new TypeAliasType;
         CXCursor location = clang_getTypeDeclaration(type);
         t->setType(makeAbsType(clang_getTypedefDeclUnderlyingType(location), parent));
         setIdTypeDecl(location, t);
         return t;
     }
 
     template<CXTypeKind TK, EnableIf<CursorKindTraits::delayedTypeName(TK) != 0> = dummy>
     AbstractType *createType(CXType, CXCursor /*parent*/)
     {
         auto t = new DelayedType;
         static const IndexedTypeIdentifier id(QLatin1String(CursorKindTraits::delayedTypeName(TK)));
         t->setIdentifier(id);
         return t;
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_Vector> = dummy>
     AbstractType *createType(CXType type, CXCursor /*parent*/)
     {
         return createDelayedType(type);
     }
 
     template<CXTypeKind TK, EnableIf<TK == CXType_Unexposed> = dummy>
     AbstractType *createType(CXType type, CXCursor parent)
     {
         // Maybe it's the ElaboratedType. E.g.: "struct Type foo();" or "NS::Type foo();" or "void foo(enum Enum e);" e.t.c.
         auto oldType = type;
 
         type = clang_getCanonicalType(type);
         bool isElaboratedType = type.kind != CXType_FunctionProto && type.kind != CXType_FunctionNoProto && type.kind != CXType_Unexposed && type.kind != CXType_Invalid && type.kind != CXType_Record;
 
         return !isElaboratedType ? createDelayedType(oldType) : makeType(type, parent);
     }
 
     template<CXCursorKind CK, EnableIf<CursorKindTraits::isIdentifiedType(CK) && !CursorKindTraits::isAliasType(CK) && CK != CXCursor_EnumConstantDecl> = dummy>
     typename IdType<CK>::Type *createType(CXCursor)
     {
         return new typename IdType<CK>::Type;
     }
 
     template<CXCursorKind CK, EnableIf<CK == CXCursor_EnumConstantDecl> = dummy>
     EnumeratorType *createType(CXCursor cursor)
     {
         auto type = new EnumeratorType;
         type->setValue<quint64>(clang_getEnumConstantDeclUnsignedValue(cursor));
         return type;
     }
 
     template<CXCursorKind CK, EnableIf<CursorKindTraits::isAliasType(CK)> = dummy>
     TypeAliasType *createType(CXCursor cursor)
     {
         auto type = new TypeAliasType;
         type->setType(makeAbsType(clang_getTypedefDeclUnderlyingType(cursor), cursor));
         return type;
     }
 
     template <CXCursorKind CK, EnableIf<CK == CXCursor_FunctionDecl> = dummy>
     AbstractType* createType(CXCursor cursor)
     {
         auto clangType = clang_getCursorType(cursor);
 
         if (clangType.kind == CXType_Unexposed) {
             // Clang sometimes can return CXType_Unexposed for CXType_FunctionProto kind. E.g. if it's AttributedType.
             return dispatchType<CXType_FunctionProto>(clangType, cursor);
         }
 
         return makeType(clangType, cursor);
     }
 
     template<CXCursorKind CK, EnableIf<CK == CXCursor_LabelStmt> = dummy>
     AbstractType *createType(CXCursor)
     {
         auto t = new DelayedType;
         static const IndexedTypeIdentifier id(QStringLiteral("Label"));
         t->setIdentifier(id);
         return t;
     }
 
     template<CXCursorKind CK, EnableIf<!CursorKindTraits::isIdentifiedType(CK) && CK != CXCursor_FunctionDecl && CK != CXCursor_LabelStmt> = dummy>
     AbstractType *createType(CXCursor cursor)
     {
         auto clangType = clang_getCursorType(cursor);
         return makeType(clangType, cursor);
     }
 //END create*
 
 //BEGIN setDeclData
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, Declaration *decl, bool setComment = true) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, MacroDefinition* decl) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, ClassMemberDeclaration *decl) const;
 
     template<CXCursorKind CK, EnableIf<CursorKindTraits::isClassTemplate(CK)> = dummy>
     void setDeclData(CXCursor cursor, ClassDeclaration* decl) const;
 
     template<CXCursorKind CK, EnableIf<!CursorKindTraits::isClassTemplate(CK)> = dummy>
     void setDeclData(CXCursor cursor, ClassDeclaration* decl) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, AbstractFunctionDeclaration* decl) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, ClassFunctionDeclaration* decl) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, FunctionDeclaration *decl, bool setComment = true) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, FunctionDefinition *decl) const;
 
     template<CXCursorKind CK>
     void setDeclData(CXCursor cursor, NamespaceAliasDeclaration *decl) const;
 
 //END setDeclData
 
 //BEGIN setDeclInCtxtData
     template<CXCursorKind CK>
     void setDeclInCtxtData(CXCursor, Declaration*)
     {
         //No-op
     }
 
     template<CXCursorKind CK>
     void setDeclInCtxtData(CXCursor cursor, ClassFunctionDeclaration *decl)
     {
         // HACK to retrieve function-constness
         // This looks like a bug in Clang -- In theory setTypeModifiers should take care of setting the const modifier
         // however, clang_isConstQualifiedType() for TK == CXType_FunctionProto always returns false
         // TODO: Debug further
         auto type = decl->abstractType();
         if (type) {
             if (ClangUtils::isConstMethod(cursor)) {
                 type->setModifiers(type->modifiers() | AbstractType::ConstModifier);
                 decl->setAbstractType(type);
             }
         }
     }
 
     template<CXCursorKind CK>
     void setDeclInCtxtData(CXCursor cursor, FunctionDefinition *def)
     {
         setDeclInCtxtData<CK>(cursor, static_cast<FunctionDeclaration*>(def));
 
         CXCursor canon = clang_getCanonicalCursor(cursor);
         if (clang_equalCursors(canon, cursor)) {
             def->setDeclarationIsDefinition(true);
         } else if (auto decl = findDeclaration(canon)) {
             def->setDeclaration(decl.data());
         }
     }
 //END setDeclInCtxtData
 
 //BEGIN setDeclType
     template<CXCursorKind CK>
     void setDeclType(Declaration *decl, typename IdType<CK>::Type *type)
     {
         setDeclType<CK>(decl, static_cast<IdentifiedType*>(type));
         setDeclType<CK>(decl, static_cast<AbstractType*>(type));
     }
 
     template<CXCursorKind CK>
     void setDeclType(Declaration *decl, IdentifiedType *type)
     {
         type->setDeclaration(decl);
     }
 
     template<CXCursorKind CK>
     void setDeclType(Declaration *decl, AbstractType *type)
     {
         decl->setAbstractType(AbstractType::Ptr(type));
     }
 //END setDeclType
 
     template<CXTypeKind TK>
     void setTypeModifiers(CXType type, AbstractType* kdevType) const;
 
     const CXFile m_file;
     const IncludeFileContexts &m_includes;
 
     DeclarationPointer findDeclaration(CXCursor cursor) const;
     void setIdTypeDecl(CXCursor typeCursor, IdentifiedType* idType) const;
 
     std::unordered_map<DUContext*, std::vector<CXCursor>> m_uses;
     /// At these location offsets (cf. @ref clang_getExpansionLocation) we encountered macro expansions
     QSet<unsigned int> m_macroExpansionLocations;
     mutable QHash<unsigned int, DeclarationPointer> m_cursorToDeclarationCache;
     CurrentContext *m_parentContext;
 
     const bool m_update;
 };
 
 //BEGIN setTypeModifiers
 template<CXTypeKind TK>
 void Visitor::setTypeModifiers(CXType type, AbstractType* kdevType) const
 {
     quint64 modifiers = 0;
     if (clang_isConstQualifiedType(type)) {
         modifiers |= AbstractType::ConstModifier;
     }
     if (clang_isVolatileQualifiedType(type)) {
         modifiers |= AbstractType::VolatileModifier;
     }
     if (TK == CXType_Short || TK == CXType_UShort) {
         modifiers |= AbstractType::ShortModifier;
     }
     if (TK == CXType_Long || TK == CXType_LongDouble || TK == CXType_ULong) {
         modifiers |= AbstractType::LongModifier;
     }
     if (TK == CXType_LongLong || TK == CXType_ULongLong) {
         modifiers |= AbstractType::LongLongModifier;
     }
     if (TK == CXType_SChar) {
         modifiers |= AbstractType::SignedModifier;
     }
     if (TK == CXType_UChar || TK == CXType_UInt || TK == CXType_UShort
         || TK == CXType_UInt128 || TK == CXType_ULong || TK == CXType_ULongLong)
     {
         modifiers |= AbstractType::UnsignedModifier;
     }
     kdevType->setModifiers(modifiers);
 }
 //END setTypeModifiers
 
 //BEGIN dispatchCursor
 
 template<CXCursorKind CK, Decision IsInClass,
          EnableIf<IsInClass == Decision::Maybe>>
 CXChildVisitResult Visitor::dispatchCursor(CXCursor cursor, CXCursor parent)
 {
     const bool decision = CursorKindTraits::isClass(clang_getCursorKind(parent));
     return decision ?
         dispatchCursor<CK, Decision::True, CursorKindTraits::isDefinition(CK)>(cursor, parent) :
         dispatchCursor<CK, Decision::False, CursorKindTraits::isDefinition(CK)>(cursor, parent);
 }
 
 template<CXCursorKind CK, Decision IsInClass, Decision IsDefinition,
          EnableIf<IsDefinition == Decision::Maybe && IsInClass != Decision::Maybe>>
 CXChildVisitResult Visitor::dispatchCursor(CXCursor cursor, CXCursor parent)
 {
     IF_DEBUG(clangDebug() << "IsInClass:" << IsInClass << "- isDefinition:" << IsDefinition;)
 
     const bool isDefinition = clang_isCursorDefinition(cursor);
     return isDefinition ?
         dispatchCursor<CK, IsInClass, Decision::True>(cursor, parent) :
         dispatchCursor<CK, IsInClass, Decision::False>(cursor, parent);
 }
 
 template<CXCursorKind CK, Decision IsInClass, Decision IsDefinition,
          EnableIf<IsInClass != Decision::Maybe && IsDefinition != Decision::Maybe>>
 CXChildVisitResult Visitor::dispatchCursor(CXCursor cursor, CXCursor parent)
 {
     IF_DEBUG(clangDebug() << "IsInClass:" << IsInClass << "- isDefinition:" << IsDefinition;)
 
     // We may end up visiting the same cursor twice in some cases
     // see discussion on https://git.reviewboard.kde.org/r/119526/
     // TODO: Investigate why this is happening in libclang
     if ((CursorKindTraits::isClass(CK) || CK == CXCursor_EnumDecl) &&
             clang_getCursorKind(parent) == CXCursor_VarDecl) {
         return CXChildVisit_Continue;
     }
 
     constexpr bool isClassMember = IsInClass == Decision::True;
     constexpr bool isDefinition = IsDefinition == Decision::True;
     constexpr bool hasContext = CursorKindTraits::isFunction(CK) || (IsDefinition == Decision::True);
     return buildDeclaration<CK, typename DeclType<CK, isDefinition, isClassMember>::Type, hasContext>(cursor);
 }
 
 //END dispatchCursor
 
 //BEGIN setDeclData
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, Declaration *decl, bool setComment) const
 {
     if (setComment)
         decl->setComment(makeComment(clang_Cursor_getParsedComment(cursor)));
     if (CursorKindTraits::isAliasType(CK)) {
         decl->setIsTypeAlias(true);
     }
     if (CK == CXCursor_Namespace)
         decl->setKind(Declaration::Namespace);
     if (CK == CXCursor_EnumDecl || CK == CXCursor_EnumConstantDecl || CursorKindTraits::isClass(CK) || CursorKindTraits::isAliasType(CK))
         decl->setKind(Declaration::Type);
 
     int isAlwaysDeprecated;
     clang_getCursorPlatformAvailability(cursor, &isAlwaysDeprecated, nullptr, nullptr, nullptr, nullptr, 0);
     decl->setDeprecated(isAlwaysDeprecated);
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, MacroDefinition* decl) const
 {
     setDeclData<CK>(cursor, static_cast<Declaration*>(decl));
 
     if (m_update) {
         decl->clearParameters();
     }
 
     auto unit = clang_Cursor_getTranslationUnit(cursor);
     auto range = clang_getCursorExtent(cursor);
 
     // TODO: Quite lacking API in libclang here.
     // No way to find out if this macro is function-like or not
     // cf. http://clang.llvm.org/doxygen/classclang_1_1MacroInfo.html
     // And no way to get the actual definition text range
     // Should be quite easy to expose that in libclang, though
     // Let' still get some basic support for this and parse on our own, it's not that difficult
     const QString contents = QString::fromUtf8(ClangUtils::getRawContents(unit, range));
     const int firstOpeningParen = contents.indexOf(QLatin1Char('('));
     const int firstWhitespace = contents.indexOf(QLatin1Char(' '));
     const bool isFunctionLike = (firstOpeningParen != -1) && (firstOpeningParen < firstWhitespace);
     decl->setFunctionLike(isFunctionLike);
 
     // now extract the actual definition text
     int start = -1;
     if (isFunctionLike) {
         const int closingParen = findClose(contents, firstOpeningParen);
         if (closingParen != -1) {
             start = closingParen + 2; // + ')' + ' '
 
             // extract macro function parameters
             const QString parameters = contents.mid(firstOpeningParen, closingParen - firstOpeningParen + 1);
             ParamIterator paramIt(QStringLiteral("():"), parameters, 0);
             while (paramIt) {
                 decl->addParameter(IndexedString(*paramIt));
                 ++paramIt;
             }
         }
     } else {
         start = firstWhitespace + 1; // + ' '
     }
     if (start == -1) {
         // unlikely: invalid macro definition, insert the complete #define statement
         decl->setDefinition(IndexedString(QLatin1String("#define ") + contents));
     } else if (start < contents.size()) {
         decl->setDefinition(IndexedString(contents.mid(start)));
     } // else: macro has no body => leave the definition text empty
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, ClassMemberDeclaration *decl) const
 {
     setDeclData<CK>(cursor, static_cast<Declaration*>(decl));
     //A CXCursor_VarDecl in a class is static (otherwise it'd be a CXCursor_FieldDecl)
     if (CK == CXCursor_VarDecl)
         decl->setStatic(true);
     decl->setAccessPolicy(CursorKindTraits::kdevAccessPolicy(clang_getCXXAccessSpecifier(cursor)));
 }
 
 template<CXCursorKind CK, EnableIf<CursorKindTraits::isClassTemplate(CK)>>
 void Visitor::setDeclData(CXCursor cursor, ClassDeclaration* decl) const
 {
     CXCursorKind kind = clang_getTemplateCursorKind(cursor);
     switch (kind) {
         case CXCursor_UnionDecl: setDeclData<CXCursor_UnionDecl>(cursor, decl); break;
         case CXCursor_StructDecl: setDeclData<CXCursor_StructDecl>(cursor, decl); break;
         case CXCursor_ClassDecl: setDeclData<CXCursor_ClassDecl>(cursor, decl); break;
         default: Q_ASSERT(false); break;
     }
 }
 
 template<CXCursorKind CK, EnableIf<!CursorKindTraits::isClassTemplate(CK)>>
 void Visitor::setDeclData(CXCursor cursor, ClassDeclaration* decl) const
 {
     if (m_update) {
         decl->clearBaseClasses();
     }
     setDeclData<CK>(cursor, static_cast<ClassMemberDeclaration*>(decl));
     if (CK == CXCursor_UnionDecl)
         decl->setClassType(ClassDeclarationData::Union);
     if (CK == CXCursor_StructDecl)
         decl->setClassType(ClassDeclarationData::Struct);
     if (clang_isCursorDefinition(cursor)) {
         decl->setDeclarationIsDefinition(true);
     }
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, AbstractFunctionDeclaration* decl) const
 {
     if (m_update) {
         decl->clearDefaultParameters();
     }
     // No setDeclData<CK>(...) here: AbstractFunctionDeclaration is an interface
     // TODO: Can we get the default arguments directly from Clang?
     // also see http://clang-developers.42468.n3.nabble.com/Finding-default-value-for-function-argument-with-clang-c-API-td4036919.html
     const QVector<QString> defaultArgs = ClangUtils::getDefaultArguments(cursor, ClangUtils::MinimumSize);
     foreach (const QString& defaultArg, defaultArgs) {
         decl->addDefaultParameter(IndexedString(defaultArg));
     }
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, ClassFunctionDeclaration* decl) const
 {
     setDeclData<CK>(cursor, static_cast<AbstractFunctionDeclaration*>(decl));
     setDeclData<CK>(cursor, static_cast<ClassMemberDeclaration*>(decl));
     decl->setAbstract(clang_CXXMethod_isPureVirtual(cursor));
     decl->setStatic(clang_CXXMethod_isStatic(cursor));
     decl->setVirtual(clang_CXXMethod_isVirtual(cursor));
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, FunctionDeclaration *decl, bool setComment) const
 {
     setDeclData<CK>(cursor, static_cast<AbstractFunctionDeclaration*>(decl));
     setDeclData<CK>(cursor, static_cast<Declaration*>(decl), setComment);
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, FunctionDefinition *decl) const
 {
     bool setComment = clang_equalCursors(clang_getCanonicalCursor(cursor), cursor);
     setDeclData<CK>(cursor, static_cast<FunctionDeclaration*>(decl), setComment);
 }
 
 template<CXCursorKind CK>
 void Visitor::setDeclData(CXCursor cursor, NamespaceAliasDeclaration *decl) const
 {
     setDeclData<CK>(cursor, static_cast<Declaration*>(decl));
     clang_visitChildren(cursor, [] (CXCursor cursor, CXCursor /*parent*/, CXClientData data) -> CXChildVisitResult {
         Q_ASSERT(clang_getCursorKind(cursor) == CXCursor_NamespaceRef);
         const auto id = QualifiedIdentifier(ClangString(clang_getCursorSpelling(cursor)).toString());
         reinterpret_cast<NamespaceAliasDeclaration*>(data)->setImportIdentifier(id);
         return CXChildVisit_Break;
     }, decl);
 }
 //END setDeclData
 
 //BEGIN build*
 template<CXCursorKind CK, class DeclType, bool hasContext>
 CXChildVisitResult Visitor::buildDeclaration(CXCursor cursor)
 {
     auto id = makeId(cursor);
     IF_DEBUG(clangDebug() << "id:" << id << "- CK:" << CK << "- DeclType:" << typeid(DeclType).name() << "- hasContext:" << hasContext;)
 
     // Code path for class declarations that may be defined "out-of-line", e.g.
     // "SomeNameSpace::SomeClass {};"
     QScopedPointer<CurrentContext> helperContext;
-    if (CursorKindTraits::isClass(CK)) {
+    if (CursorKindTraits::isClass(CK) || CursorKindTraits::isFunction(CK)) {
         const auto lexicalParent = clang_getCursorLexicalParent(cursor);
         const auto semanticParent = clang_getCursorSemanticParent(cursor);
         const bool isOutOfLine = !clang_equalCursors(lexicalParent, semanticParent);
         if (isOutOfLine) {
             const QString scope = ClangUtils::getScope(cursor);
             auto context = createContext<CK, DUContext::Helper>(cursor, QualifiedIdentifier(scope));
             helperContext.reset(new CurrentContext(context));
         }
     }
 
     // if helperContext is null, this is a no-op
     PushValue<CurrentContext*> pushCurrent(m_parentContext, helperContext.isNull() ? m_parentContext : helperContext.data());
 
     if (hasContext) {
         auto context = createContext<CK, CursorKindTraits::contextType(CK)>(cursor, QualifiedIdentifier(id));
         createDeclaration<CK, DeclType>(cursor, id, context);
         CurrentContext newParent(context);
         PushValue<CurrentContext*> pushCurrent(m_parentContext, &newParent);
         clang_visitChildren(cursor, &visitCursor, this);
         return CXChildVisit_Continue;
     }
     createDeclaration<CK, DeclType>(cursor, id, nullptr);
     return CXChildVisit_Recurse;
 }
 
 CXChildVisitResult Visitor::buildParmDecl(CXCursor cursor)
 {
     // There is no need to create declarations for anonymous function parameters e.g.: void f(int);
     // Currently clang_Cursor_getSpellingNameRange returns not empty ranges for anonymous parameters. So we use clang_getCursorSpelling here.
     if (ClangString(clang_getCursorSpelling(cursor)).isEmpty()) {
         return CXChildVisit_Recurse;
     }
 
     return buildDeclaration<CXCursor_ParmDecl, typename DeclType<CXCursor_ParmDecl, false, false>::Type, false>(cursor);
 }
 
 CXChildVisitResult Visitor::buildUse(CXCursor cursor)
 {
     m_uses[m_parentContext->context].push_back(cursor);
     return cursor.kind == CXCursor_DeclRefExpr || cursor.kind == CXCursor_MemberRefExpr ?
         CXChildVisit_Recurse : CXChildVisit_Continue;
 }
 
 CXChildVisitResult Visitor::buildMacroExpansion(CXCursor cursor)
 {
     buildUse(cursor);
 
     // cache that we encountered a macro expansion at this location
     unsigned int offset;
     clang_getSpellingLocation(clang_getCursorLocation(cursor), nullptr, nullptr, nullptr, &offset);
     m_macroExpansionLocations << offset;
 
     return CXChildVisit_Recurse;
 }
 
 CXChildVisitResult Visitor::buildCompoundStatement(CXCursor cursor)
 {
     if (m_parentContext->context->type() == DUContext::Function)
     {
         auto context = createContext<CXCursor_CompoundStmt, DUContext::Other>(cursor);
         CurrentContext newParent(context);
         PushValue<CurrentContext*> pushCurrent(m_parentContext, &newParent);
         clang_visitChildren(cursor, &visitCursor, this);
         return CXChildVisit_Continue;
     }
     return CXChildVisit_Recurse;
 }
 
 CXChildVisitResult Visitor::buildCXXBaseSpecifier(CXCursor cursor)
 {
     auto currentContext = m_parentContext->context;
 
     bool virtualInherited = clang_isVirtualBase(cursor);
     Declaration::AccessPolicy access = CursorKindTraits::kdevAccessPolicy(clang_getCXXAccessSpecifier(cursor));
 
     auto classDeclCursor = clang_getCursorReferenced(cursor);
     auto decl = findDeclaration(classDeclCursor);
     if (!decl) {
         // this happens for templates with template-dependent base classes e.g. - dunno whether we can/should do more here
         clangDebug() << "failed to find declaration for base specifier:" << clang_getCursorDisplayName(cursor);
         return CXChildVisit_Recurse;
     }
 
     DUChainWriteLocker lock;
     contextImportDecl(currentContext, decl);
     auto classDecl = dynamic_cast<ClassDeclaration*>(currentContext->owner());
     Q_ASSERT(classDecl);
 
     classDecl->addBaseClass({decl->indexedType(), access, virtualInherited});
     return CXChildVisit_Recurse;
 }
 //END build*
 
 DeclarationPointer Visitor::findDeclaration(CXCursor cursor) const
 {
     const auto cursorHash = clang_hashCursor(cursor);
     const auto it = m_cursorToDeclarationCache.constFind(cursorHash);
     if (it != m_cursorToDeclarationCache.constEnd()) {
         return *it;
     }
 
     // fallback, and cache result
     auto decl = ClangHelpers::findDeclaration(cursor, m_includes);
 
     m_cursorToDeclarationCache.insert(cursorHash, decl);
     return decl;
 }
 
 void Visitor::setIdTypeDecl(CXCursor typeCursor, IdentifiedType* idType) const
 {
     DeclarationPointer decl = findDeclaration(typeCursor);
     DUChainReadLocker lock;
     if (decl) {
         idType->setDeclaration(decl.data());
     }
 }
 
 AbstractType *Visitor::makeType(CXType type, CXCursor parent)
 {
     #define UseKind(TypeKind) case TypeKind: return dispatchType<TypeKind>(type, parent)
     switch (type.kind) {
     UseKind(CXType_Void);
     UseKind(CXType_Bool);
     UseKind(CXType_Short);
     UseKind(CXType_UShort);
     UseKind(CXType_Int);
     UseKind(CXType_UInt);
     UseKind(CXType_Long);
     UseKind(CXType_ULong);
     UseKind(CXType_LongLong);
     UseKind(CXType_ULongLong);
     UseKind(CXType_Float);
     UseKind(CXType_LongDouble);
     UseKind(CXType_Double);
     UseKind(CXType_Char_U);
     UseKind(CXType_Char_S);
     UseKind(CXType_UChar);
     UseKind(CXType_SChar);
     UseKind(CXType_Char16);
     UseKind(CXType_Char32);
     UseKind(CXType_Pointer);
     UseKind(CXType_MemberPointer);
     UseKind(CXType_ObjCObjectPointer);
     UseKind(CXType_ConstantArray);
     UseKind(CXType_VariableArray);
     UseKind(CXType_IncompleteArray);
     UseKind(CXType_DependentSizedArray);
     UseKind(CXType_LValueReference);
     UseKind(CXType_RValueReference);
     UseKind(CXType_FunctionProto);
     UseKind(CXType_Record);
     UseKind(CXType_Enum);
     UseKind(CXType_Typedef);
     UseKind(CXType_Int128);
     UseKind(CXType_UInt128);
     UseKind(CXType_Vector);
     UseKind(CXType_Unexposed);
     UseKind(CXType_WChar);
     UseKind(CXType_ObjCInterface);
     UseKind(CXType_ObjCId);
     UseKind(CXType_ObjCClass);
     UseKind(CXType_ObjCSel);
     UseKind(CXType_NullPtr);
     case CXType_Invalid:
         return nullptr;
     default:
         qCWarning(KDEV_CLANG) << "Unhandled type:" << type.kind << clang_getTypeSpelling(type);
         return nullptr;
     }
 }
 
 RangeInRevision rangeInRevisionForUse(CXCursor cursor, CXCursorKind referencedCursorKind, CXSourceRange useRange, const QSet<unsigned int>& macroExpansionLocations)
 {
     auto range = ClangRange(useRange).toRangeInRevision();
 
     //TODO: Fix in clang, happens for operator<<, operator<, probably more
     if (clang_Range_isNull(useRange)) {
         useRange = clang_getCursorExtent(cursor);
         range = ClangRange(useRange).toRangeInRevision();
     }
 
     if (referencedCursorKind == CXCursor_ConversionFunction) {
         range.end = range.start;
         range.start.column--;
     }
 
     // For uses inside macro expansions, create an empty use range at the spelling location
     // the empty range is required in order to not "overlap" the macro expansion range
     // and to allow proper navigation for the macro expansion
     // also see JSON test 'macros.cpp'
     if (clang_getCursorKind(cursor) != CXCursor_MacroExpansion) {
         unsigned int expansionLocOffset;
         const auto spellingLocation = clang_getRangeStart(useRange);
         clang_getExpansionLocation(spellingLocation, nullptr, nullptr, nullptr, &expansionLocOffset);
         if (macroExpansionLocations.contains(expansionLocOffset)) {
             unsigned int spellingLocOffset;
             clang_getSpellingLocation(spellingLocation, nullptr, nullptr, nullptr, &spellingLocOffset);
             if (spellingLocOffset == expansionLocOffset) {
                 range.end = range.start;
             }
         }
     } else {
         // Workaround for wrong use range returned by clang for macro expansions
         const auto contents = ClangUtils::getRawContents(clang_Cursor_getTranslationUnit(cursor), useRange);
         const int firstOpeningParen = contents.indexOf('(');
         if (firstOpeningParen != -1) {
             range.end.column = range.start.column + firstOpeningParen;
             range.end.line = range.start.line;
         }
     }
 
     return range;
 }
 
 Visitor::Visitor(CXTranslationUnit tu, CXFile file,
                  const IncludeFileContexts& includes, const bool update)
     : m_file(file)
     , m_includes(includes)
     , m_parentContext(nullptr)
     , m_update(update)
 {
     CXCursor tuCursor = clang_getTranslationUnitCursor(tu);
     CurrentContext parent(includes[file]);
     m_parentContext = &parent;
     clang_visitChildren(tuCursor, &visitCursor, this);
 
     TopDUContext *top = m_parentContext->context->topContext();
     if (m_update) {
         DUChainWriteLocker lock;
         top->deleteUsesRecursively();
     }
     for (const auto &contextUses : m_uses) {
         for (const auto &cursor : contextUses.second) {
             auto referenced = referencedCursor(cursor);
             if (clang_Cursor_isNull(referenced)) {
                 continue;
             }
 
             auto used = findDeclaration(referenced);
             if (!used) {
                 DUChainReadLocker lock;
                 DeclarationPointer decl = ClangHelpers::findForwardDeclaration(clang_getCursorType(referenced), contextUses.first, referenced);
                 used = decl;
                 if (!used) {
                     continue;
                 }
             }
 
             const auto useRange = clang_getCursorReferenceNameRange(cursor, 0, 0);
             const auto range = rangeInRevisionForUse(cursor, referenced.kind, useRange, m_macroExpansionLocations);
 
             DUChainWriteLocker lock;
             auto usedIndex = top->indexForUsedDeclaration(used.data());
             contextUses.first->createUse(usedIndex, range);
         }
     }
 }
 
 //END Visitor
 
 CXChildVisitResult visitCursor(CXCursor cursor, CXCursor parent, CXClientData data)
 {
     Visitor *visitor = static_cast<Visitor*>(data);
 
     const auto kind = clang_getCursorKind(cursor);
 
     auto location = clang_getCursorLocation(cursor);
     CXFile file;
     clang_getFileLocation(location, &file, nullptr, nullptr, nullptr);
     // don't skip MemberRefExpr with invalid location, see also:
     // http://lists.cs.uiuc.edu/pipermail/cfe-dev/2015-May/043114.html
     if (!ClangUtils::isFileEqual(file, visitor->m_file) && (file || kind != CXCursor_MemberRefExpr)) {
         return CXChildVisit_Continue;
     }
 
 #define UseCursorKind(CursorKind, ...) case CursorKind: return visitor->dispatchCursor<CursorKind>(__VA_ARGS__);
     switch (kind)
     {
     UseCursorKind(CXCursor_UnexposedDecl, cursor, parent);
     UseCursorKind(CXCursor_StructDecl, cursor, parent);
     UseCursorKind(CXCursor_UnionDecl, cursor, parent);
     UseCursorKind(CXCursor_ClassDecl, cursor, parent);
     UseCursorKind(CXCursor_EnumDecl, cursor, parent);
     UseCursorKind(CXCursor_FieldDecl, cursor, parent);
     UseCursorKind(CXCursor_EnumConstantDecl, cursor, parent);
     UseCursorKind(CXCursor_FunctionDecl, cursor, parent);
     UseCursorKind(CXCursor_VarDecl, cursor, parent);
     UseCursorKind(CXCursor_TypeAliasDecl, cursor, parent);
     UseCursorKind(CXCursor_TypedefDecl, cursor, parent);
     UseCursorKind(CXCursor_CXXMethod, cursor, parent);
     UseCursorKind(CXCursor_Namespace, cursor, parent);
     UseCursorKind(CXCursor_NamespaceAlias, cursor, parent);
     UseCursorKind(CXCursor_Constructor, cursor, parent);
     UseCursorKind(CXCursor_Destructor, cursor, parent);
     UseCursorKind(CXCursor_ConversionFunction, cursor, parent);
     UseCursorKind(CXCursor_TemplateTypeParameter, cursor, parent);
     UseCursorKind(CXCursor_NonTypeTemplateParameter, cursor, parent);
     UseCursorKind(CXCursor_TemplateTemplateParameter, cursor, parent);
     UseCursorKind(CXCursor_FunctionTemplate, cursor, parent);
     UseCursorKind(CXCursor_ClassTemplate, cursor, parent);
     UseCursorKind(CXCursor_ClassTemplatePartialSpecialization, cursor, parent);
     UseCursorKind(CXCursor_ObjCInterfaceDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCCategoryDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCProtocolDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCPropertyDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCIvarDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCInstanceMethodDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCClassMethodDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCImplementationDecl, cursor, parent);
     UseCursorKind(CXCursor_ObjCCategoryImplDecl, cursor, parent);
     UseCursorKind(CXCursor_MacroDefinition, cursor, parent);
     UseCursorKind(CXCursor_LabelStmt, cursor, parent);
     case CXCursor_TypeRef:
     case CXCursor_TemplateRef:
     case CXCursor_NamespaceRef:
     case CXCursor_MemberRef:
     case CXCursor_LabelRef:
     case CXCursor_OverloadedDeclRef:
     case CXCursor_VariableRef:
     case CXCursor_DeclRefExpr:
     case CXCursor_MemberRefExpr:
     case CXCursor_ObjCClassRef:
         return visitor->buildUse(cursor);
     case CXCursor_MacroExpansion:
         return visitor->buildMacroExpansion(cursor);
     case CXCursor_CompoundStmt:
         return visitor->buildCompoundStatement(cursor);
     case CXCursor_CXXBaseSpecifier:
         return visitor->buildCXXBaseSpecifier(cursor);
     case CXCursor_ParmDecl:
         return visitor->buildParmDecl(cursor);
     default:
         return CXChildVisit_Recurse;
     }
 }
 
 }
 
 namespace Builder {
 
 void visit(CXTranslationUnit tu, CXFile file, const IncludeFileContexts& includes, const bool update)
 {
     Visitor visitor(tu, file, includes, update);
 }
 
 void enableJSONTestRun()
 {
     s_jsonTestRun = true;
 }
 
 }
\ No newline at end of file
diff --git a/tests/files/outofline.cpp b/tests/files/outofline.cpp
index 30e14f7eb7..ad65a3fb4d 100644
--- a/tests/files/outofline.cpp
+++ b/tests/files/outofline.cpp
@@ -1,12 +1,12 @@
 class foo
 {
     /// "qualifiedIdentifier": "foo::bar",
     /// "isDefinition": false,
     /// "definition": {
     ///     "range": "[(11, 9), (11, 12)]",
-    ///     "qualifiedIdentifier": "foo::bar", "EXPECT_FAIL": {"qualifiedIdentifier": "the parent context is not set properly"}
+    ///     "qualifiedIdentifier": "foo::bar"
     /// }
     int bar();
 };
 
 int foo::bar() {}
diff --git a/tests/test_codecompletion.cpp b/tests/test_codecompletion.cpp
index 1b569f04ca..fca922d7ac 100644
--- a/tests/test_codecompletion.cpp
+++ b/tests/test_codecompletion.cpp
@@ -1,728 +1,727 @@
 /*
  * Copyright 2014  David Stevens <dgedstevens@gmail.com>
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  * Copyright 2015 Milian Wolff <mail@milianw.de>
  * Copyright 2015 Sergey Kalinichev <kalinichev.so.0@gmail.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "test_codecompletion.h"
 
 #include <tests/testcore.h>
 #include <tests/autotestshell.h>
 #include <tests/testfile.h>
 
 #include "duchain/parsesession.h"
 #include "util/clangtypes.h"
 
 #include <language/codecompletion/codecompletiontesthelper.h>
 #include <language/duchain/types/functiontype.h>
 
 #include "codecompletion/completionhelper.h"
 #include "codecompletion/context.h"
 #include "codecompletion/includepathcompletioncontext.h"
 
 #include <KTextEditor/Editor>
 #include <KTextEditor/Document>
 #include <KTextEditor/View>
 
 #include <ktexteditor_version.h>
 #if KTEXTEDITOR_VERSION < QT_VERSION_CHECK(5, 10, 0)
 Q_DECLARE_METATYPE(KTextEditor::Cursor);
 #endif
 
 QTEST_MAIN(TestCodeCompletion);
 
 using namespace KDevelop;
 
 using ClangCodeCompletionItemTester = CodeCompletionItemTester<ClangCodeCompletionContext>;
 
 struct CompletionItems {
     CompletionItems(){}
     CompletionItems(const KTextEditor::Cursor& position, const QStringList& completions, const QStringList& declarationItems = {})
         : position(position)
         , completions(completions)
         , declarationItems(declarationItems)
     {};
     KTextEditor::Cursor position;
     QStringList completions;
     QStringList declarationItems; ///< completion items that have associated declarations. Declarations with higher match quality at the top. @sa KTextEditor::CodeCompletionModel::MatchQuality
 };
 Q_DECLARE_TYPEINFO(CompletionItems, Q_MOVABLE_TYPE);
 Q_DECLARE_METATYPE(CompletionItems);
 
 
 struct CompletionPriorityItem
 {
     CompletionPriorityItem(const QString name, int matchQuality = 0, int inheritanceDepth = 0, const QString failMessage = {})
         : name(name)
         , failMessage(failMessage)
         , matchQuality(matchQuality)
         , inheritanceDepth(inheritanceDepth)
     {}
 
     QString name;
     QString failMessage;
     int matchQuality;
     int inheritanceDepth;
 };
 
 struct CompletionPriorityItems : public CompletionItems
 {
     CompletionPriorityItems(){}
     CompletionPriorityItems(const KTextEditor::Cursor& position, const QList<CompletionPriorityItem>& completions)
         : CompletionItems(position, {})
         , completions(completions)
     {};
 
     QList<CompletionPriorityItem> completions;
 };
 
 Q_DECLARE_TYPEINFO(CompletionPriorityItems, Q_MOVABLE_TYPE);
 Q_DECLARE_METATYPE(CompletionPriorityItems);
 
 void TestCodeCompletion::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_DISABLE_PLUGINS", "kdevcppsupport"));
     AutoTestShell::init();
     TestCore::initialize(Core::NoUi);
 }
 
 void TestCodeCompletion::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 namespace {
 
 void executeCompletionTest(const QString& code, const CompletionItems& expectedCompletionItems,
                            const ClangCodeCompletionContext::ContextFilters& filters = ClangCodeCompletionContext::ContextFilters(
                                 ClangCodeCompletionContext::NoBuiltins |
                                 ClangCodeCompletionContext::NoMacros))
 {
     TestFile file(code, "cpp");
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     DUContextPointer topPtr(top);
 
     // don't hold DUChain lock when constructing ClangCodeCompletionContext
     lock.unlock();
 
     // TODO: We should not need to pass 'session' to the context, should just use the base class ctor
     auto context = new ClangCodeCompletionContext(topPtr, sessionData, file.url().toUrl(), expectedCompletionItems.position, QString());
     context->setFilters(filters);
 
     lock.lock();
     auto tester = ClangCodeCompletionItemTester(QExplicitlySharedDataPointer<ClangCodeCompletionContext>(context));
 
     int previousMatchQuality = 10;
     for(const auto& declarationName : expectedCompletionItems.declarationItems){
         const auto declarationItem = tester.findItem(declarationName);
         QVERIFY(declarationItem);
         QVERIFY(declarationItem->declaration());
 
         auto matchQuality = tester.itemData(declarationItem, KTextEditor::CodeCompletionModel::Name, KTextEditor::CodeCompletionModel::MatchQuality).toInt();
         QVERIFY(matchQuality <= previousMatchQuality);
         previousMatchQuality = matchQuality;
     }
 
     tester.names.sort();
     QCOMPARE(tester.names, expectedCompletionItems.completions);
 }
 
 void executeCompletionPriorityTest(const QString& code, const CompletionPriorityItems& expectedCompletionItems,
                            const ClangCodeCompletionContext::ContextFilters& filters = ClangCodeCompletionContext::ContextFilters(
                                 ClangCodeCompletionContext::NoBuiltins |
                                 ClangCodeCompletionContext::NoMacros))
 {
     TestFile file(code, "cpp");
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     DUContextPointer topPtr(top);
 
     // don't hold DUChain lock when constructing ClangCodeCompletionContext
     lock.unlock();
 
     auto context = new ClangCodeCompletionContext(topPtr, sessionData, file.url().toUrl(), expectedCompletionItems.position, QString());
     context->setFilters(filters);
 
     lock.lock();
     auto tester = ClangCodeCompletionItemTester(QExplicitlySharedDataPointer<ClangCodeCompletionContext>(context));
 
     for(const auto& declaration : expectedCompletionItems.completions){
         const auto declarationItem = tester.findItem(declaration.name);
-        QEXPECT_FAIL("protected-access2", declaration.failMessage.toUtf8().constData(), Abort);
         QVERIFY(declarationItem);
         QVERIFY(declarationItem->declaration());
 
         auto matchQuality = tester.itemData(declarationItem, KTextEditor::CodeCompletionModel::Name, KTextEditor::CodeCompletionModel::MatchQuality).toInt();
         auto inheritanceDepth = declarationItem->inheritanceDepth();
 
         if(!declaration.failMessage.isEmpty()){
             QEXPECT_FAIL("", declaration.failMessage.toUtf8().constData(), Continue);
         }
         QVERIFY(matchQuality == declaration.matchQuality && inheritanceDepth == declaration.inheritanceDepth);
     }
 }
 
 using IncludeTester = CodeCompletionItemTester<IncludePathCompletionContext>;
 
 QExplicitlySharedDataPointer<IncludePathCompletionContext> executeIncludePathCompletion(TestFile* file, const KTextEditor::Cursor& position)
 {
     if (!file->parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST)) {
         QTest::qFail("Failed to parse source file.", __FILE__, __LINE__);
         return {};
     }
 
     DUChainReadLocker lock;
     auto top = file->topContext();
     if (!top) {
         QTest::qFail("Failed to parse source file.", __FILE__, __LINE__);
         return {};
     }
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     if (!sessionData) {
         QTest::qFail("Failed to acquire parse session data.", __FILE__, __LINE__);
         return {};
     }
 
     DUContextPointer topPtr(top);
 
     lock.unlock();
 
     auto text = file->fileContents();
     int textLength = -1;
     if (position.isValid()) {
         textLength = 0;
         for (int i = 0; i < position.line(); ++i) {
             textLength = text.indexOf('\n', textLength) + 1;
         }
         textLength += position.column();
     }
     auto context = new IncludePathCompletionContext(topPtr, sessionData, file->url().toUrl(), position, text.mid(0, textLength));
     return QExplicitlySharedDataPointer<IncludePathCompletionContext>{context};
 }
 
 }
 
 void TestCodeCompletion::testClangCodeCompletion()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testClangCodeCompletion_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("assignment")
         << "int foo = 5; \nint bar = "
         << CompletionItems{{1,9}, {
             "bar",
             "foo",
         }, {"bar","foo"}};
     QTest::newRow("dotmemberaccess")
         << "class Foo { public: void foo() {} bool operator=(Foo &&) }; int main() { Foo f; \nf. "
         << CompletionItems{{1, 2}, {
             "foo",
             "operator="
         }, {"foo",  "operator="}};
     QTest::newRow("arrowmemberaccess")
         << "class Foo { public: void foo() {} }; int main() { Foo* f = new Foo; \nf-> }"
         << CompletionItems{{1, 3}, {
             "foo"
         }, {"foo"}};
     QTest::newRow("enum-case")
         << "enum Foo { foo, bar }; int main() { Foo f; switch (f) {\ncase "
         << CompletionItems{{1,4}, {
             "bar",
             "foo",
         }, {"foo", "bar"}};
     QTest::newRow("only-private")
         << "class SomeStruct { private: void priv() {} };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
         }};
     QTest::newRow("private-friend")
         << "class SomeStruct { private: void priv() {} friend int main(); };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
             "priv",
         }, {"priv"}};
     QTest::newRow("private-public")
         << "class SomeStruct { public: void pub() {} private: void priv() {} };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
             "pub",
         }, {"pub"}};
     QTest::newRow("protected-public")
         << "class SomeStruct { public: void pub() {} protected: void prot() {} };\n"
            "int main() { SomeStruct s;\ns. "
         << CompletionItems{{2, 2}, {
             "pub",
         }, {"pub"}};
     QTest::newRow("localVariable")
         << "int main() { int localVariable;\nloc "
         << CompletionItems{{1, 3},
             {"localVariable","main"},
             {"localVariable", "main"}
         };
     QTest::newRow("globalVariable")
         << "int globalVariable;\nint main() { \ngl "
         << CompletionItems{{2, 2},
             {"globalVariable","main"},
             {"globalVariable", "main"}
         };
     QTest::newRow("namespaceVariable")
         << "namespace NameSpace{int variable};\nint main() { \nNameSpace:: "
         << CompletionItems{{2, 11},
             {"variable"},
             {"variable"}
         };
     QTest::newRow("parentVariable")
         << "class A{public: int m_variable;};class B : public A{};\nint main() { B b;\nb. "
         << CompletionItems{{2, 2},
             {"m_variable"},
             {"m_variable"}
         };
     QTest::newRow("itemsPriority")
         << "class A; class B; void f(A); int main(){ A c; B b;f(\n} "
         << CompletionItems{{1, 0},
             {"A", "B", "b", "c", "f", "main"},
             {"c", "A", "b", "B"}
     };
     QTest::newRow("function-arguments")
         << "class Abc; int f(Abc){\n "
         << CompletionItems{{1, 0}, {
             "Abc",
             "f",
         }};
 }
 
 void TestCodeCompletion::testVirtualOverride()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems, ClangCodeCompletionContext::NoClangCompletion);
 }
 
 void TestCodeCompletion::testVirtualOverride_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("basic")
         <<  "class Foo { virtual void foo(); virtual void foo(char c); virtual char foo(char c, int i, double d); };\n"
             "class Bar : Foo \n{void foo(char c) override;\n}"
         << CompletionItems{{3, 1}, {"foo()", "foo(char c, int i, double d)"}};
 
     QTest::newRow("template")
         << "template<class T1, class T2> class Foo { virtual T2 foo(T1 a, T2 b, int i); virtual T2 overridden(T1 a); } ;\n"
            "class Bar : Foo<char, double> \n{double overridden(char a) override;\n}"
         << CompletionItems{{3, 1}, {"foo(char a, double b, int i)"}};
 
     QTest::newRow("nested-template")
         << "template<class T1, class T2> class Foo { virtual T2 foo(T1 a, T2 b, int i); virtual T2 overridden(T1 a, T2 b, int i); } ;\n"
            "template<class T1, class T2> class Baz { };\n"
            "class Bar : Foo<char, Baz<char, double>> \n{Baz<char, double> overridden(char a, Baz<char, double> b, int i) override;\n}"
         << CompletionItems{{4, 1}, {"foo(char a, Baz<char, double> b, int i)"}};
 
     QTest::newRow("multi")
         << "class Foo { virtual int foo(int i); virtual int overridden(int i); };\n"
            "class Baz { virtual char baz(char c); };\n"
            "class Bar : Foo, Baz \n{int overridden(int i) override;\n}"
         << CompletionItems{{4, 1}, {"baz(char c)", "foo(int i)"}};
 
     QTest::newRow("deep")
         << "class Foo { virtual int foo(int i); virtual int overridden(int i); };\n"
            "class Baz : Foo { };\n"
            "class Bar : Baz \n{int overridden(int i) overriden;\n}"
         << CompletionItems{{4, 1}, {"foo(int i)"}};
 
     QTest::newRow("pure")
         << "class Foo { virtual void foo() = 0; virtual void overridden() = 0;};\n"
            "class Bar : Foo \n{void overridden() override;\n};"
         << CompletionItems{{3, 0}, {"foo() = 0"}};
 
     QTest::newRow("const")
         << "class Foo { virtual void foo(const int b) const; virtual void overridden(const int b) const; }\n;"
            "class Bar : Foo \n{void overridden(const int b) const override;\n}"
         << CompletionItems{{3, 1}, {"foo(const int b) const"}};
 }
 
 void TestCodeCompletion::testImplement()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems, ClangCodeCompletionContext::NoClangCompletion);
 }
 
 void TestCodeCompletion::testImplement_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("basic")
         << "int foo(char c, int i); \n"
         << CompletionItems{{1, 0}, {"foo(char c, int i)"}};
 
     QTest::newRow("class")
         << "class Foo { \n"
            "int bar(char c, int i); \n\n"
            "}; \n"
         << CompletionItems{{2, 0}, {}};
 
     QTest::newRow("class2")
         << "class Foo { \n"
             "int bar(char c, int i); \n\n"
             "}; \n"
         << CompletionItems{{4, 0}, {"Foo::bar(char c, int i)"}};
 
     QTest::newRow("namespace")
         << "namespace Foo { \n"
            "int bar(char c, int i); \n\n"
            "}; \n"
         << CompletionItems{{2, 0}, {"bar(char c, int i)"}};
 
     QTest::newRow("namespace2")
         << "namespace Foo { \n"
            "int bar(char c, int i); \n\n"
            "}; \n"
         << CompletionItems{{4, 0}, {"Foo::bar(char c, int i)"}};
 
     QTest::newRow("two-namespace")
         << "namespace Foo { int bar(char c, int i); };\n"
            "namespace Foo {\n"
            "};\n"
         << CompletionItems{{2, 0}, {"bar(char c, int i)"}};
 
     QTest::newRow("destructor")
         << "class Foo { ~Foo(); }\n"
         << CompletionItems{{1, 0}, {"Foo::~Foo()"}};
 
     QTest::newRow("constructor")
         << "class Foo { \n"
                  "Foo(int i); \n"
                  "}; \n"
         << CompletionItems{{3, 1}, {"Foo::Foo(int i)"}};
 
     QTest::newRow("template")
         << "template<typename T> class Foo { T bar(T t); };\n"
         << CompletionItems{{1, 1}, {"Foo<T>::bar(T t)"}};
 
     QTest::newRow("specialized-template")
         << "template<typename T> class Foo { \n"
            "T bar(T t); \n"
            "}; \n"
            "template<typename T> T Foo<T>::bar(T t){} \n"
            "template<> class Foo<int> { \n"
            "int bar(int t); \n"
            "}\n"
         << CompletionItems{{6, 1}, {"Foo<int>::bar(int t)"}};
 
     QTest::newRow("nested-class")
         << "class Foo { \n"
            "class Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{3, 1}, {}};
 
     QTest::newRow("nested-class2")
         << "class Foo { \n"
            "class Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{5, 1}, {}};
 
     QTest::newRow("nested-class3")
         << "class Foo { \n"
            "class Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{7, 1}, {"Foo::Bar::baz(char c, int i)"}};
 
     QTest::newRow("nested-namespace")
         << "namespace Foo { \n"
            "namespace Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{3, 1}, {"baz(char c, int i)"}};
 
     QTest::newRow("nested-namespace2")
         << "namespace Foo { \n"
            "namespace Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{5, 1}, {"Bar::baz(char c, int i)"}};
 
     QTest::newRow("nested-namespace3")
         << "namespace Foo { \n"
            "namespace Bar { \n"
            "int baz(char c, int i); \n\n"
            "}; \n\n"
            "}; \n\n"
         << CompletionItems {{7, 1}, {"Foo::Bar::baz(char c, int i)"}};
 
     QTest::newRow("partial-template")
         << "template<typename T> class Foo { \n"
            "template<typename U> class Bar;\n"
            "template<typename U> class Bar<U*> { void baz(T t, U u); }\n"
            "}\n"
         << CompletionItems{{5,1}, {"Foo<T>::Bar<U *>::baz(T t, U u)"}};
 
     QTest::newRow("variadic")
         << "int foo(...); int bar(int i, ...); \n"
         << CompletionItems{{1, 1}, {"bar(int i, ...)", "foo(...)"}};
 
     QTest::newRow("const")
         << "class Foo { int bar() const; };"
         << CompletionItems{{3, 1}, {"Foo::bar() const"}};
 
     QTest::newRow("multiple-methods")
         << "class Foo { int bar(); void foo(); char asdf() const; };"
         << CompletionItems{{3, 1}, {"Foo::asdf() const", "Foo::bar()", "Foo::foo()"}};
 }
 
 void TestCodeCompletion::testInvalidCompletions()
 {
     QFETCH(QString, code);
     QFETCH(CompletionItems, expectedItems);
 
     executeCompletionTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testInvalidCompletions_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionItems>("expectedItems");
 
     QTest::newRow("invalid-context-incomment")
         << "class Foo { int bar() const; };\n/*\n*/"
         << CompletionItems{{2, 0}, {}};
 }
 
 void TestCodeCompletion::testIncludePathCompletion_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<KTextEditor::Cursor>("cursor");
     QTest::addColumn<QString>("itemId");
     QTest::addColumn<QString>("result");
 
     QTest::newRow("global-1") << QString("#include ") << KTextEditor::Cursor(0, 9)
                               << QString("iostream") << QString("#include <iostream>");
     QTest::newRow("global-2") << QString("#include <") << KTextEditor::Cursor(0, 9)
                               << QString("iostream") << QString("#include <iostream>");
     QTest::newRow("global-3") << QString("#include <") << KTextEditor::Cursor(0, 10)
                               << QString("iostream") << QString("#include <iostream>");
     QTest::newRow("global-4") << QString("#  include <") << KTextEditor::Cursor(0, 12)
                               << QString("iostream") << QString("#  include <iostream>");
     QTest::newRow("global-5") << QString("#  include   <") << KTextEditor::Cursor(0, 14)
                               << QString("iostream") << QString("#  include   <iostream>");
     QTest::newRow("global-6") << QString("#  include   <> /* 1 */") << KTextEditor::Cursor(0, 14)
                               << QString("iostream") << QString("#  include   <iostream> /* 1 */");
     QTest::newRow("global-7") << QString("#  include /* 1 */ <> /* 1 */") << KTextEditor::Cursor(0, 21)
                               << QString("iostream") << QString("#  include /* 1 */ <iostream> /* 1 */");
     QTest::newRow("global-8") << QString("# /* 1 */ include /* 1 */ <> /* 1 */") << KTextEditor::Cursor(0, 28)
                               << QString("iostream") << QString("# /* 1 */ include /* 1 */ <iostream> /* 1 */");
     QTest::newRow("global-9") << QString("#include <cstdint>") << KTextEditor::Cursor(0, 10)
                               << QString("iostream") << QString("#include <iostream>");
     QTest::newRow("global-10") << QString("#include <cstdint>") << KTextEditor::Cursor(0, 14)
                               << QString("cstdint") << QString("#include <cstdint>");
     QTest::newRow("global-11") << QString("#include <cstdint>") << KTextEditor::Cursor(0, 17)
                               << QString("cstdint") << QString("#include <cstdint>");
     QTest::newRow("local-0") << QString("#include \"") << KTextEditor::Cursor(0, 10)
                               << QString("foo/") << QString("#include \"foo/\"");
     QTest::newRow("local-1") << QString("#include \"foo/\"") << KTextEditor::Cursor(0, 14)
                               << QString("bar/") << QString("#include \"foo/bar/\"");
     QTest::newRow("local-2") << QString("#include \"foo/") << KTextEditor::Cursor(0, 14)
                               << QString("bar/") << QString("#include \"foo/bar/\"");
     QTest::newRow("local-3") << QString("# /* 1 */ include /* 1 */ \"\" /* 1 */") << KTextEditor::Cursor(0, 28)
                               << QString("foo/") << QString("# /* 1 */ include /* 1 */ \"foo/\" /* 1 */");
     QTest::newRow("local-4") << QString("# /* 1 */ include /* 1 */ \"foo/\" /* 1 */") << KTextEditor::Cursor(0, 31)
                               << QString("bar/") << QString("# /* 1 */ include /* 1 */ \"foo/bar/\" /* 1 */");
     QTest::newRow("local-5") << QString("#include \"foo/\"") << KTextEditor::Cursor(0, 10)
                               << QString("foo/") << QString("#include \"foo/\"");
     QTest::newRow("local-6") << QString("#include \"foo/asdf\"") << KTextEditor::Cursor(0, 10)
                               << QString("foo/") << QString("#include \"foo/\"");
     QTest::newRow("local-7") << QString("#include \"foo/asdf\"") << KTextEditor::Cursor(0, 14)
                               << QString("bar/") << QString("#include \"foo/bar/\"");
 }
 
 void TestCodeCompletion::testIncludePathCompletion()
 {
     QFETCH(QString, code);
     QFETCH(KTextEditor::Cursor, cursor);
     QFETCH(QString, itemId);
     QFETCH(QString, result);
 
     QTemporaryDir tempDir;
     QDir dir(tempDir.path());
     QVERIFY(dir.mkpath("foo/bar/asdf"));
     TestFile file(code, "cpp", 0, tempDir.path());
     IncludeTester tester(executeIncludePathCompletion(&file, cursor));
     QVERIFY(tester.completionContext);
     QVERIFY(tester.completionContext->isValid());
 
     auto item = tester.findItem(itemId);
     QVERIFY(item);
 
     KTextEditor::Editor* editor = KTextEditor::Editor::instance();
     QVERIFY(editor);
 
     auto doc = std::unique_ptr<KTextEditor::Document>(editor->createDocument(this));
     QVERIFY(doc.get());
     QVERIFY(doc->openUrl(file.url().toUrl()));
 
     QWidget parent;
     auto view = doc->createView(&parent);
     item->execute(view, KTextEditor::Range(cursor, cursor));
     QCOMPARE(doc->text(), result);
 
     const auto newCursor = view->cursorPosition();
     QCOMPARE(newCursor.line(), cursor.line());
     if (!itemId.endsWith('/')) {
         // file inserted, cursor should be at end of line
         QCOMPARE(newCursor.column(), doc->lineLength(cursor.line()));
     } else {
         // directory inserted, cursor should be before the " or >
         const auto cursorChar = doc->characterAt(newCursor);
         QVERIFY(cursorChar == '"' || cursorChar == '>');
     }
 }
 
 void TestCodeCompletion::testIncludePathCompletionLocal()
 {
     TestFile header("int foo() { return 42; }\n", "h");
     TestFile impl("#include \"", "cpp", &header);
 
     IncludeTester tester(executeIncludePathCompletion(&impl, {0, 10}));
     QVERIFY(tester.names.contains(header.url().toUrl().fileName()));
     QVERIFY(!tester.names.contains("iostream"));
 }
 
 void TestCodeCompletion::testOverloadedFunctions()
 {
     TestFile file("void f(); int f(int); void f(int, double){\n ", "cpp");
     QVERIFY(file.parseAndWait(TopDUContext::AllDeclarationsContextsUsesAndAST));
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     const ParseSessionData::Ptr sessionData(dynamic_cast<ParseSessionData*>(top->ast().data()));
     QVERIFY(sessionData);
 
     DUContextPointer topPtr(top);
     lock.unlock();
 
     const auto context = new ClangCodeCompletionContext(topPtr, sessionData, file.url().toUrl(), {1, 0}, QString());
     context->setFilters(ClangCodeCompletionContext::ContextFilters(
                             ClangCodeCompletionContext::NoBuiltins |
                             ClangCodeCompletionContext::NoMacros));
     lock.lock();
     const auto tester = ClangCodeCompletionItemTester(QExplicitlySharedDataPointer<ClangCodeCompletionContext>(context));
     QCOMPARE(tester.items.size(), 3);
     for (const auto& item : tester.items) {
         auto function = item->declaration()->type<FunctionType>();
         const QString display = item->declaration()->identifier().toString() + function->partToString(FunctionType::SignatureArguments);
         const QString itemDisplay = tester.itemData(item).toString() + tester.itemData(item, KTextEditor:: CodeCompletionModel::Arguments).toString();
         QCOMPARE(display, itemDisplay);
     }
 
     QVERIFY(tester.items[0]->declaration().data() != tester.items[1]->declaration().data());
     QVERIFY(tester.items[0]->declaration().data() != tester.items[2]->declaration().data());
     QVERIFY(tester.items[1]->declaration().data() != tester.items[2]->declaration().data());
 }
 
 void TestCodeCompletion::testCompletionPriority()
 {
     QFETCH(QString, code);
     QFETCH(CompletionPriorityItems, expectedItems);
 
     executeCompletionPriorityTest(code, expectedItems);
 }
 
 void TestCodeCompletion::testCompletionPriority_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<CompletionPriorityItems>("expectedItems");
 
     QTest::newRow("pointer")
         << "class A{}; class B{}; class C : public B{}; int main(){A* a; B* b; C* c; b =\n "
         << CompletionPriorityItems{{1,0}, {{"a", 0, 21}, {"b", 9, 0},
         {"c", 8, 0, QStringLiteral("Pointer to derived class is not added to the Best Matches group")}}};
 
     QTest::newRow("class")
         << "class A{}; class B{}; class C : public B{}; int main(){A a; B b; C c; b =\n "
         << CompletionPriorityItems{{1,0}, {{"a", 0, 21}, {"b", 9, 0},
         {"c", 8, 0, QStringLiteral("Derived class is not added to the Best Matches group")}}};
 
     QTest::newRow("primary-types")
         << "class A{}; int main(){A a; int b; bool c = \n "
         << CompletionPriorityItems{{1,0}, {{"a", 0, 34}, {"b", 8, 0}, {"c", 9, 0}}};
 
     QTest::newRow("reference")
         << "class A{}; class B{}; class C : public B{};"
            "int main(){A tmp; A& a = tmp; C tmp2; C& c = tmp2; B& b =\n ;}"
         << CompletionPriorityItems{{1,0}, {{"a", 0, 21}, {"b", 9, 0},
         {"c", 8, 0, QStringLiteral("Reference to derived class is not added to the Best Matches group")}}};
 
     QTest::newRow("typedef")
         << "struct A{}; struct B{}; typedef A AA; typedef B BB; void f(A p);"
            "int main(){ BB b; AA a; f(\n }"
         << CompletionPriorityItems{{1,0}, {{"a", 9, 0}, {"b", 0, 21}}};
 
     QTest::newRow("returnType")
         << "struct A{}; struct B{}; struct Test{A f();B g(); Test() { A a =\n }};"
         << CompletionPriorityItems{{1,0}, {{"f", 9, 0}, {"g", 0, 21}}};
 
     QTest::newRow("template")
         << "template <typename T> class Class{}; template <typename T> class Class2{};"
            "int main(){ Class<int> a; Class2<int> b =\n }"
         << CompletionPriorityItems{{1,0}, {{"b", 9, 0}, {"a", 0, 21}}};
 
     QTest::newRow("protected-access")
         << "class Base { protected: int m_protected; };"
            "class Derived: public Base {public: void g(){\n }};"
         << CompletionPriorityItems{{1,0}, {{"m_protected", 0, 37}}};
 
     QTest::newRow("protected-access2")
         << "class Base { protected: int m_protected; };"
            "class Derived: public Base {public: void f();};"
            "void Derived::f(){\n }"
-        << CompletionPriorityItems{{1,0}, {{"m_protected", 0, 37, QStringLiteral("Out of line methods have wrong parent context attached (Global instead of Class)")}}};
+        << CompletionPriorityItems{{1,0}, {{"m_protected", 0, 37}}};
 }