diff --git a/plugins/clang/clangsupport.cpp b/plugins/clang/clangsupport.cpp
index 4b6713aae6..f632678064 100644
--- a/plugins/clang/clangsupport.cpp
+++ b/plugins/clang/clangsupport.cpp
@@ -1,440 +1,442 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
     Copyright 2014 Kevin Funk <kfunk@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "clangsupport.h"
 
 #include "clangparsejob.h"
 
 #include "util/clangdebug.h"
 #include "util/clangtypes.h"
 #include "util/clangutils.h"
 
 #include "codecompletion/model.h"
 
 #include "clanghighlighting.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/idocumentcontroller.h>
 
 #include "codegen/clangrefactoring.h"
 #include "codegen/clangclasshelper.h"
 #include "codegen/adaptsignatureassistant.h"
 #include "duchain/documentfinderhelpers.h"
 #include "duchain/navigationwidget.h"
 #include "duchain/clangindex.h"
 #include "duchain/clanghelpers.h"
 #include "duchain/macrodefinition.h"
 #include "duchain/clangparsingenvironmentfile.h"
 #include "duchain/duchainutils.h"
 
 #include <language/assistant/staticassistantsmanager.h>
 #include <language/assistant/renameassistant.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/codecompletion/codecompletion.h>
 #include <language/highlighting/codehighlighting.h>
 #include <language/interfaces/editorcontext.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/use.h>
 #include <language/editor/documentcursor.h>
 
 #include "clangsettings/sessionsettings/sessionsettings.h"
 
 #include <KActionCollection>
 #include <KPluginFactory>
 
 #include <KTextEditor/View>
 #include <KTextEditor/ConfigInterface>
 
 #include <QAction>
 
 K_PLUGIN_FACTORY_WITH_JSON(KDevClangSupportFactory, "kdevclangsupport.json", registerPlugin<ClangSupport>(); )
 
 using namespace KDevelop;
 
 namespace {
 
 QPair<QString, KTextEditor::Range> lineInDocument(const QUrl &url, const KTextEditor::Cursor& position)
 {
     KDevelop::IDocument* doc = ICore::self()->documentController()->documentForUrl(url);
     if (!doc || !doc->textDocument() || !ICore::self()->documentController()->activeTextDocumentView()) {
         return {};
     }
 
     const int lineNumber = position.line();
     const int lineLength = doc->textDocument()->lineLength(lineNumber);
     KTextEditor::Range range(lineNumber, 0, lineNumber, lineLength);
     QString line = doc->textDocument()->text(range);
     return {line, range};
 }
 
 QPair<TopDUContextPointer, KTextEditor::Range> importedContextForPosition(const QUrl &url, const KTextEditor::Cursor& position)
 {
     auto pair = lineInDocument(url, position);
 
     const QString line = pair.first;
     if (line.isEmpty())
         return {{}, KTextEditor::Range::invalid()};
 
     KTextEditor::Range wordRange = ClangUtils::rangeForIncludePathSpec(line, pair.second);
     if (!wordRange.isValid() || !wordRange.contains(position)) {
         return {{}, KTextEditor::Range::invalid()};
     }
 
     // Since this is called by the editor while editing, use a fast timeout so the editor stays responsive
     DUChainReadLocker lock(nullptr, 100);
     if (!lock.locked()) {
         clangDebug() << "Failed to lock the du-chain in time";
         return {TopDUContextPointer(), KTextEditor::Range::invalid()};
     }
 
     TopDUContext* topContext = DUChainUtils::standardContextForUrl(url);
     if (line.isEmpty() || !topContext || !topContext->parsingEnvironmentFile()) {
         return {TopDUContextPointer(), KTextEditor::Range::invalid()};
     }
 
     // It's an #include, find out which file was included at the given line
     foreach(const DUContext::Import &imported, topContext->importedParentContexts()) {
         auto context = imported.context(nullptr);
         if (context) {
             if(topContext->transformFromLocalRevision(topContext->importPosition(context)).line() == wordRange.start().line()) {
                 if (auto importedTop = dynamic_cast<TopDUContext*>(context))
                     return {TopDUContextPointer(importedTop), wordRange};
             }
         }
     }
 
     // The last resort. Check if the file is already included (maybe recursively from another files).
     // This is needed as clang doesn't visit (clang_getInclusions) those inclusions.
     // TODO: Maybe create an assistant that'll report whether the file is already included?
     auto includeName = line.mid(wordRange.start().column(), wordRange.end().column() - wordRange.start().column());
 
     if (!includeName.isEmpty()) {
         if (includeName.startsWith(QLatin1Char('.'))) {
             const Path dir = Path(url).parent();
             includeName = Path(dir, includeName).toLocalFile();
         }
 
         const auto recursiveImports = topContext->recursiveImportIndices();
         auto iterator = recursiveImports.iterator();
         while (iterator) {
             const auto str = (*iterator).url().str();
             if (str == includeName || (str.endsWith(includeName) && str[str.size()-includeName.size()-1] == QLatin1Char('/'))) {
                 return {TopDUContextPointer((*iterator).data()), wordRange};
             }
             ++iterator;
         }
     }
 
     return {{}, KTextEditor::Range::invalid()};
 }
 
 QPair<TopDUContextPointer, Use> macroExpansionForPosition(const QUrl &url, const KTextEditor::Cursor& position)
 {
     TopDUContext* topContext = DUChainUtils::standardContextForUrl(url);
     if (topContext) {
         int useAt = topContext->findUseAt(topContext->transformToLocalRevision(position));
         if (useAt >= 0) {
             Use use = topContext->uses()[useAt];
             if (dynamic_cast<MacroDefinition*>(use.usedDeclaration(topContext))) {
                 return {TopDUContextPointer(topContext), use};
             }
         }
     }
     return {{}, Use()};
 }
 
 }
 
 ClangSupport::ClangSupport(QObject* parent, const QVariantList& )
     : IPlugin( QStringLiteral("kdevclangsupport"), parent )
     , ILanguageSupport()
     , m_highlighting(nullptr)
     , m_refactoring(nullptr)
     , m_index(nullptr)
 {
+    clangDebug() << "Detected Clang version:" << ClangHelpers::clangVersion();
+
     {
         const auto builtinDir = ClangHelpers::clangBuiltinIncludePath();
         const auto headerToCheck = QLatin1String("cpuid.h");
         if (!QFile::exists(builtinDir + QLatin1Char('/') + headerToCheck)) {
             setErrorDescription(i18n("The clang builtin include path \"%1\" is invalid (missing %2 header).\n"
                                      "Try setting the KDEV_CLANG_BUILTIN_DIR environment variable manually to fix this.\n"
                                      "See also: https://bugs.kde.org/show_bug.cgi?id=393779", builtinDir, headerToCheck));
             return;
         }
     }
 
     setXMLFile( QStringLiteral("kdevclangsupport.rc") );
 
     ClangIntegration::DUChainUtils::registerDUChainItems();
 
     m_highlighting = new ClangHighlighting(this);
     m_refactoring = new ClangRefactoring(this);
     m_index.reset(new ClangIndex);
 
     auto model = new KDevelop::CodeCompletion( this, new ClangCodeCompletionModel(m_index.data(), this), name() );
     connect(model, &CodeCompletion::registeredToView,
             this, &ClangSupport::disableKeywordCompletion);
     connect(model, &CodeCompletion::unregisteredFromView,
             this, &ClangSupport::enableKeywordCompletion);
     const auto& mimeTypes = DocumentFinderHelpers::mimeTypesList();
     for (const auto& type : mimeTypes) {
         KDevelop::IBuddyDocumentFinder::addFinder(type, this);
     }
 
     auto assistantsManager = core()->languageController()->staticAssistantsManager();
     assistantsManager->registerAssistant(StaticAssistant::Ptr(new RenameAssistant(this)));
     assistantsManager->registerAssistant(StaticAssistant::Ptr(new AdaptSignatureAssistant(this)));
 
     connect(ICore::self()->documentController(), &IDocumentController::documentActivated,
             this, &ClangSupport::documentActivated);
 }
 
 ClangSupport::~ClangSupport()
 {
     parseLock()->lockForWrite();
     // By locking the parse-mutexes, we make sure that parse jobs get a chance to finish in a good state
     parseLock()->unlock();
 
     const auto& mimeTypes = DocumentFinderHelpers::mimeTypesList();
     for (const auto& type : mimeTypes) {
         KDevelop::IBuddyDocumentFinder::removeFinder(type);
     }
 
     ClangIntegration::DUChainUtils::unregisterDUChainItems();
 }
 
 KDevelop::ConfigPage* ClangSupport::configPage(int number, QWidget* parent)
 {
     return number == 0 ? new SessionSettings(parent) : nullptr;
 }
 
 int ClangSupport::configPages() const
 {
     return 1;
 }
 
 ParseJob* ClangSupport::createParseJob(const IndexedString& url)
 {
     return new ClangParseJob(url, this);
 }
 
 QString ClangSupport::name() const
 {
     return QStringLiteral("clang");
 }
 
 ICodeHighlighting* ClangSupport::codeHighlighting() const
 {
     return m_highlighting;
 }
 
 BasicRefactoring* ClangSupport::refactoring() const
 {
     return m_refactoring;
 }
 
 ICreateClassHelper* ClangSupport::createClassHelper() const
 {
     return new ClangClassHelper;
 }
 
 ClangIndex* ClangSupport::index()
 {
     return m_index.data();
 }
 
 bool ClangSupport::areBuddies(const QUrl &url1, const QUrl& url2)
 {
     return DocumentFinderHelpers::areBuddies(url1, url2);
 }
 
 bool ClangSupport::buddyOrder(const QUrl &url1, const QUrl& url2)
 {
     return DocumentFinderHelpers::buddyOrder(url1, url2);
 }
 
 QVector<QUrl> ClangSupport::potentialBuddies(const QUrl& url) const
 {
     return DocumentFinderHelpers::potentialBuddies(url);
 }
 
 void ClangSupport::createActionsForMainWindow (Sublime::MainWindow* /*window*/, QString& _xmlFile, KActionCollection& actions)
 {
     _xmlFile = xmlFile();
 
     QAction* renameDeclarationAction = actions.addAction(QStringLiteral("code_rename_declaration"));
     renameDeclarationAction->setText( i18n("Rename Declaration") );
     renameDeclarationAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-rename")));
     actions.setDefaultShortcut(renameDeclarationAction, Qt::CTRL | Qt::SHIFT | Qt::Key_R);
     connect(renameDeclarationAction, &QAction::triggered,
             m_refactoring, &ClangRefactoring::executeRenameAction);
 
     QAction* moveIntoSourceAction = actions.addAction(QStringLiteral("code_move_definition"));
     moveIntoSourceAction->setText(i18n("Move into Source"));
     actions.setDefaultShortcut(moveIntoSourceAction, Qt::CTRL | Qt::ALT | Qt::Key_S);
     connect(moveIntoSourceAction, &QAction::triggered,
             m_refactoring, &ClangRefactoring::executeMoveIntoSourceAction);
 }
 
 KDevelop::ContextMenuExtension ClangSupport::contextMenuExtension(KDevelop::Context* context, QWidget* parent)
 {
     ContextMenuExtension cm;
     EditorContext *ec = dynamic_cast<KDevelop::EditorContext *>(context);
 
     if (ec && ICore::self()->languageController()->languagesForUrl(ec->url()).contains(this)) {
         // It's a C++ file, let's add our context menu.
         m_refactoring->fillContextMenu(cm, context, parent);
     }
     return cm;
 }
 
 KTextEditor::Range ClangSupport::specialLanguageObjectRange(const QUrl &url, const KTextEditor::Cursor& position)
 {
     DUChainReadLocker lock;
     const QPair<TopDUContextPointer, Use> macroExpansion = macroExpansionForPosition(url, position);
     if (macroExpansion.first) {
         return macroExpansion.first->transformFromLocalRevision(macroExpansion.second.m_range);
     }
 
     const QPair<TopDUContextPointer, KTextEditor::Range> import = importedContextForPosition(url, position);
     if(import.first) {
         return import.second;
     }
 
     return KTextEditor::Range::invalid();
 }
 
 QPair<QUrl, KTextEditor::Cursor> ClangSupport::specialLanguageObjectJumpCursor(const QUrl &url, const KTextEditor::Cursor& position)
 {
     const QPair<TopDUContextPointer, KTextEditor::Range> import = importedContextForPosition(url, position);
     DUChainReadLocker lock;
     if (import.first) {
         return qMakePair(import.first->url().toUrl(), KTextEditor::Cursor(0,0));
     }
 
     return {{}, KTextEditor::Cursor::invalid()};
 }
 
 QWidget* ClangSupport::specialLanguageObjectNavigationWidget(const QUrl &url, const KTextEditor::Cursor& position)
 {
     DUChainReadLocker lock;
     const QPair<TopDUContextPointer, Use> macroExpansion = macroExpansionForPosition(url, position);
     if (macroExpansion.first) {
         Declaration* declaration = macroExpansion.second.usedDeclaration(macroExpansion.first.data());
         const MacroDefinition::Ptr macroDefinition(dynamic_cast<MacroDefinition*>(declaration));
         Q_ASSERT(macroDefinition);
         auto rangeInRevision = macroExpansion.first->transformFromLocalRevision(macroExpansion.second.m_range.start);
         return new ClangNavigationWidget(macroDefinition, DocumentCursor(IndexedString(url), rangeInRevision));
     }
 
     const QPair<TopDUContextPointer, KTextEditor::Range> import = importedContextForPosition(url, position);
 
     if (import.first) {
         return import.first->createNavigationWidget();
     }
     return nullptr;
 }
 
 TopDUContext* ClangSupport::standardContext(const QUrl &url, bool /*proxyContext*/)
 {
     ClangParsingEnvironment env;
     return DUChain::self()->chainForDocument(url, &env);
 }
 
 void ClangSupport::documentActivated(IDocument* doc)
 {
     TopDUContext::Features features;
     {
         DUChainReadLocker lock;
         auto ctx = DUChainUtils::standardContextForUrl(doc->url());
         if (!ctx) {
             return;
         }
 
         auto file = ctx->parsingEnvironmentFile();
         if (!file) {
             return;
         }
 
         if (file->type() != CppParsingEnvironment) {
             return;
         }
 
         if (file->needsUpdate()) {
             return;
         }
 
         features = ctx->features();
     }
 
     const auto indexedUrl = IndexedString(doc->url());
 
     auto sessionData = ClangIntegration::DUChainUtils::findParseSessionData(indexedUrl, index()->translationUnitForUrl(IndexedString(doc->url())));
     if (sessionData) {
         return;
     }
 
     if ((features & TopDUContext::AllDeclarationsContextsAndUses) != TopDUContext::AllDeclarationsContextsAndUses) {
         // the file was parsed in simplified mode, we need to reparse it to get all data
         // now that its opened in the editor
         features = TopDUContext::AllDeclarationsContextsAndUses;
     } else {
         features = static_cast<TopDUContext::Features>(ClangParseJob::AttachASTWithoutUpdating | features);
         if (ICore::self()->languageController()->backgroundParser()->isQueued(indexedUrl)) {
             // The document is already scheduled for parsing (happens when opening a project with an active document)
             // The background parser will optimize the previous request out, so we need to update highlighting
             features = static_cast<TopDUContext::Features>(ClangParseJob::UpdateHighlighting | features);
         }
     }
     ICore::self()->languageController()->backgroundParser()->addDocument(indexedUrl, features);
 }
 
 static void setKeywordCompletion(KTextEditor::View* view, bool enabled)
 {
     if (auto config = qobject_cast<KTextEditor::ConfigInterface*>(view)) {
         config->setConfigValue(QStringLiteral("keyword-completion"), enabled);
     }
 }
 
 int ClangSupport::suggestedReparseDelayForChange(KTextEditor::Document* /*doc*/, const KTextEditor::Range& /*changedRange*/,
                                                  const QString& /*changedText*/, bool /*removal*/) const
 {
     return ILanguageSupport::DefaultDelay;
 }
 
 void ClangSupport::disableKeywordCompletion(KTextEditor::View* view)
 {
     setKeywordCompletion(view, false);
 }
 
 void ClangSupport::enableKeywordCompletion(KTextEditor::View* view)
 {
     setKeywordCompletion(view, true);
 }
 
 #include "clangsupport.moc"
diff --git a/plugins/clang/duchain/clanghelpers.cpp b/plugins/clang/duchain/clanghelpers.cpp
index d8ad89aab6..77fde1548c 100644
--- a/plugins/clang/duchain/clanghelpers.cpp
+++ b/plugins/clang/duchain/clanghelpers.cpp
@@ -1,356 +1,395 @@
 /*
  * Copyright 2014  Olivier de Gaalon <olivier.jg@gmail.com>
  * 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 "clanghelpers.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/backgroundparser/urlparselock.h>
 
 #include "builder.h"
 #include "parsesession.h"
 #include "clangparsingenvironmentfile.h"
 #include "clangindex.h"
 #include "clangducontext.h"
-
+#include "util/clangdebug.h"
 #include "util/clangtypes.h"
 
 #include "libclang_include_path.h"
 
+#include <QCoreApplication>
+#include <QDir>
+#include <QFileInfo>
+#include <QRegularExpression>
+
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace {
 
 CXChildVisitResult visitCursor(CXCursor cursor, CXCursor, CXClientData data)
 {
     if (cursor.kind != CXCursor_InclusionDirective) {
         return CXChildVisit_Continue;
     }
 
     auto imports = static_cast<Imports*>(data);
     CXFile file = clang_getIncludedFile(cursor);
     if(!file){
         return CXChildVisit_Continue;
     }
 
     CXSourceLocation location = clang_getCursorLocation(cursor);
     CXFile parentFile;
     uint line, column;
     clang_getFileLocation(location, &parentFile, &line, &column, nullptr);
 
     foreach (const auto& import, imports->values(parentFile)) {
         // clang_getInclusions doesn't include the same import twice, so we shouldn't do it too.
         if (import.file == file) {
             return CXChildVisit_Continue;
         }
     }
 
     imports->insert(parentFile, {file, CursorInRevision(line-1, column-1)});
 
     return CXChildVisit_Recurse;
 }
 
 ReferencedTopDUContext createTopContext(const IndexedString& path, const ClangParsingEnvironment& environment)
 {
     ClangParsingEnvironmentFile* file = new ClangParsingEnvironmentFile(path, environment);
     ReferencedTopDUContext context = new ClangTopDUContext(path, RangeInRevision(0, 0, INT_MAX, INT_MAX), file);
     DUChain::self()->addDocumentChain(context);
     context->updateImportsCache();
     return context;
 }
 
 }
 
 Imports ClangHelpers::tuImports(CXTranslationUnit tu)
 {
     Imports imports;
 
     // Intentionally don't use clang_getInclusions here, as it skips already visited inclusions
     // which makes TestDUChain::testNestedImports fail
     CXCursor tuCursor = clang_getTranslationUnitCursor(tu);
     clang_visitChildren(tuCursor, &visitCursor, &imports);
 
     return imports;
 }
 
 bool importLocationLessThan(const Import& lhs, const Import& rhs)
 {
     return lhs.location.line < rhs.location.line;
 }
 
 ReferencedTopDUContext ClangHelpers::buildDUChain(CXFile file, const Imports& imports, const ParseSession& session,
                                                   TopDUContext::Features features, IncludeFileContexts& includedFiles,
                                                   ClangIndex* index, const std::function<bool()>& abortFunction)
 {
     if (includedFiles.contains(file)) {
         return {};
     }
 
     if (abortFunction && abortFunction()) {
         return {};
     }
 
     // prevent recursion
     includedFiles.insert(file, {});
 
     // ensure DUChain for imports are built properly, and in correct order
     QList<Import> sortedImports = imports.values(file);
     std::sort(sortedImports.begin(), sortedImports.end(), importLocationLessThan);
 
     foreach(const auto& import, sortedImports) {
         buildDUChain(import.file, imports, session, features, includedFiles, index, abortFunction);
     }
 
     const IndexedString path(QDir(ClangString(clang_getFileName(file)).toString()).canonicalPath());
     if (path.isEmpty()) {
         // may happen when the file gets removed before the job is run
         return {};
     }
 
     const auto& environment = session.environment();
 
     bool update = false;
     UrlParseLock urlLock(path);
     ReferencedTopDUContext context;
     {
         DUChainWriteLocker lock;
         context = DUChain::self()->chainForDocument(path, &environment);
         if (!context) {
             context = ::createTopContext(path, environment);
         } else {
             update = true;
         }
 
         includedFiles.insert(file, context);
         if (update) {
             auto envFile = ClangParsingEnvironmentFile::Ptr(dynamic_cast<ClangParsingEnvironmentFile*>(context->parsingEnvironmentFile().data()));
             Q_ASSERT(envFile);
             if (!envFile)
                 return context;
 
             /* NOTE: When we are here, then either the translation unit or one of its headers was changed.
              *       Thus we must always update the translation unit to propagate the change(s).
              *       See also: https://bugs.kde.org/show_bug.cgi?id=356327
              *       This assumes that headers are independent, we may need to improve that in the future
              *       and also update header files more often when other files included therein got updated.
              */
             if (path != environment.translationUnitUrl() && !envFile->needsUpdate(&environment) && envFile->featuresSatisfied(features)) {
                 return context;
             } else {
                 //TODO: don't attempt to update if this environment is worse quality than the outdated one
                 if (index && envFile->environmentQuality() < environment.quality()) {
                     index->pinTranslationUnitForUrl(environment.translationUnitUrl(), path);
                 }
                 envFile->setEnvironment(environment);
                 envFile->setModificationRevision(ModificationRevision::revisionForFile(context->url()));
             }
 
             context->clearImportedParentContexts();
         }
         context->setFeatures(features);
 
         foreach(const auto& import, sortedImports) {
             auto ctx = includedFiles.value(import.file);
             if (!ctx) {
                 // happens for cyclic imports
                 continue;
             }
             context->addImportedParentContext(ctx, import.location);
         }
         context->updateImportsCache();
     }
 
     const auto problems = session.problemsForFile(file);
     {
         DUChainWriteLocker lock;
         context->setProblems(problems);
     }
 
     Builder::visit(session.unit(), file, includedFiles, update);
 
     DUChain::self()->emitUpdateReady(path, context);
 
     return context;
 }
 
 DeclarationPointer ClangHelpers::findDeclaration(CXSourceLocation location, const QualifiedIdentifier& id, const ReferencedTopDUContext& top)
 {
     if (!top) {
         // may happen for cyclic includes
         return {};
     }
 
     auto cursor = CursorInRevision(ClangLocation(location));
     DUChainReadLocker lock;
 
     if (!id.isEmpty()) {
         const auto& decls = top->findDeclarations(id);
         for (Declaration* decl : decls) {
             if (decl->range().contains(cursor) ||
                 (decl->range().isEmpty() && decl->range().start == cursor))
             {
                 return DeclarationPointer(decl);
             }
         }
     }
 
     // there was no match based on the IDs, try the classical
     // range based search (very slow)
 
     Q_ASSERT(top);
     if (DUContext *local = top->findContextAt(cursor)) {
         if (local->owner() && local->owner()->range().contains(cursor)) {
            return DeclarationPointer(local->owner());
         }
         return DeclarationPointer(local->findDeclarationAt(cursor));
     }
     return {};
 }
 
 DeclarationPointer ClangHelpers::findDeclaration(CXCursor cursor, const IncludeFileContexts& includes)
 {
     auto location = clang_getCursorLocation(cursor);
     CXFile file = nullptr;
     clang_getFileLocation(location, &file, nullptr, nullptr, nullptr);
     if (!file) {
         return {};
     }
 
     // build a qualified identifier by following the chain of semantic parents
     QList<Identifier> ids;
     CXCursor currentCursor = cursor;
     while (currentCursor.kind != CXCursor_TranslationUnit &&
            currentCursor.kind != CXCursor_InvalidFile)
     {
         ids << Identifier(ClangString(clang_getCursorSpelling(currentCursor)).toString());
         currentCursor = clang_getCursorSemanticParent(currentCursor);
     }
     QualifiedIdentifier qid;
     for (int i = ids.size()-1; i >= 0; --i)
     {
         qid.push(ids[i]);
     }
 
     return findDeclaration(location, qid, includes.value(file));
 }
 
 DeclarationPointer ClangHelpers::findDeclaration(CXType type, const IncludeFileContexts& includes)
 {
     CXCursor cursor = clang_getTypeDeclaration(type);
     return findDeclaration(cursor, includes);
 }
 
 DeclarationPointer ClangHelpers::findForwardDeclaration(CXType type, DUContext* context, CXCursor cursor)
 {
     if(type.kind != CXType_Record && type.kind != CXType_ObjCInterface && type.kind != CXType_ObjCClass){
         return {};
     }
 
     auto qualifiedIdentifier = QualifiedIdentifier(ClangString(clang_getTypeSpelling(type)).toString());
 
     DUChainReadLocker lock;
     const auto decls = context->findDeclarations(qualifiedIdentifier,
         CursorInRevision(ClangLocation(clang_getCursorLocation(cursor)))
     );
 
     for (auto decl : decls) {
         if (decl->isForwardDeclaration()) {
             return DeclarationPointer(decl);
         }
     }
     return {};
 }
 
 RangeInRevision ClangHelpers::cursorSpellingNameRange(CXCursor cursor, const Identifier& id)
 {
     auto range = ClangRange(clang_Cursor_getSpellingNameRange(cursor, 0, 0)).toRangeInRevision();
 #if CINDEX_VERSION_MINOR < 29
     auto kind = clang_getCursorKind(cursor);
     // Clang used to report invalid ranges for destructors and methods like 'operator='
     if (kind == CXCursor_Destructor || kind == CXCursor_CXXMethod) {
         range.end.column = range.start.column + id.toString().length();
     }
 #endif
     Q_UNUSED(id);
     return range;
 }
 
 QStringList ClangHelpers::headerExtensions()
 {
     static const QStringList headerExtensions = {
             QStringLiteral("h"),
             QStringLiteral("H"),
             QStringLiteral("hh"),
             QStringLiteral("hxx"),
             QStringLiteral("hpp"),
             QStringLiteral("tlh"),
             QStringLiteral("h++"),
     };
     return headerExtensions;
 }
 
 QStringList ClangHelpers::sourceExtensions()
 {
     static const QStringList sourceExtensions = {
         QStringLiteral("c"),
         QStringLiteral("cc"),
         QStringLiteral("cpp"),
         QStringLiteral("c++"),
         QStringLiteral("cxx"),
         QStringLiteral("C"),
         QStringLiteral("m"),
         QStringLiteral("mm"),
         QStringLiteral("M"),
         QStringLiteral("inl"),
         QStringLiteral("_impl.h"),
     };
     return sourceExtensions;
 }
 
 bool ClangHelpers::isSource(const QString& path)
 {
     const auto& extensions = sourceExtensions();
     return std::any_of(extensions.constBegin(), extensions.constEnd(),
                        [&](const QString& ext) { return path.endsWith(ext); });
 }
 
 bool ClangHelpers::isHeader(const QString& path)
 {
     const auto& extensions = headerExtensions();
     return std::any_of(extensions.constBegin(), extensions.constEnd(),
                        [&](const QString& ext) { return path.endsWith(ext); });
 }
 
+QString ClangHelpers::clangVersion()
+{
+    static const auto clangVersion = []() -> QString {
+        // NOTE: The apidocs for clang_getClangVersion() clearly state it shouldn't be used for parsing
+        // but there's no other way to retrieve the Clang version at runtime at this point...
+        const ClangString version(clang_getClangVersion());
+        clangDebug() << "Full Clang version:" << version;
+
+        // samples:
+        //   clang version 6.0.1 (trunk 321709) (git@github.com:llvm-mirror/llvm.git 5136df4d089a086b70d452160ad5451861269498)
+        //   clang version 7.0.0-svn341916-1~exp1~20180911115939.26 (branches/release_70)
+        QRegularExpression re(QStringLiteral("^clang version (\\d+\\.\\d+\\.\\d+)"));
+        const auto match = re.match(version.toString());
+        if (!match.hasMatch())
+            return {};
+
+        return match.captured(1); // return e.g. 7.0.0
+    }();
+    return clangVersion;
+}
+
 QString ClangHelpers::clangBuiltinIncludePath()
 {
     static const auto dir = []() -> QString {
-        auto dir = qgetenv("KDEV_CLANG_BUILTIN_DIR");
-        if (dir.isEmpty()) {
-            dir = KDEV_CLANG_BUILTIN_DIR;
+        auto dir = QString::fromUtf8(qgetenv("KDEV_CLANG_BUILTIN_DIR"));
+        if (!dir.isEmpty()) {
+            clangDebug() << "Using dir from $KDEV_CLANG_BUILTIN_DIR:" << dir;
+            return dir;
+        }
+
+#ifdef Q_OS_WIN32
+        // attempt to use the bundled copy on Windows
+        dir = QDir::cleanPath(QStringLiteral("%1/../lib/clang/%2/include")
+            .arg(QCoreApplication::applicationDirPath(), clangVersion()));
+        clangDebug() << "Trying" << dir;
+        if (QFileInfo(dir).isDir()) {
+            return dir;
         }
-        return QString::fromUtf8(dir);
+#endif
+
+        clangDebug() << "Using builtin dir:" << KDEV_CLANG_BUILTIN_DIR;
+        return QString::fromUtf8(KDEV_CLANG_BUILTIN_DIR);
     }();
     return dir;
 }
diff --git a/plugins/clang/duchain/clanghelpers.h b/plugins/clang/duchain/clanghelpers.h
index 8459104b8f..39dcf59bb1 100644
--- a/plugins/clang/duchain/clanghelpers.h
+++ b/plugins/clang/duchain/clanghelpers.h
@@ -1,112 +1,114 @@
 /*
  * Copyright 2014  Olivier de Gaalon <olivier.jg@gmail.com>
  * Copyright 2014  Milian Wolff <mail@milianw.de>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef CLANGHELPERS_H
 #define CLANGHELPERS_H
 
 #include "clangprivateexport.h"
 
 #include <language/duchain/duchainpointer.h>
 #include <language/duchain/topducontext.h>
 
 #include <clang-c/Index.h>
 
 #include <functional>
 
 class ParseSession;
 class ClangIndex;
 
 struct Import
 {
     CXFile file;
     KDevelop::CursorInRevision location;
 };
 
 Q_DECLARE_TYPEINFO(Import, Q_MOVABLE_TYPE);
 
 using Imports = QMultiHash<CXFile, Import>;
 using IncludeFileContexts = QHash<CXFile, KDevelop::ReferencedTopDUContext>;
 
 namespace ClangHelpers {
 
 KDevelop::DeclarationPointer findDeclaration(CXSourceLocation cursor, const KDevelop::QualifiedIdentifier& id, const KDevelop::ReferencedTopDUContext& top);
 KDevelop::DeclarationPointer findDeclaration(CXCursor cursor, const IncludeFileContexts& includes);
 KDevelop::DeclarationPointer findDeclaration(CXType type, const IncludeFileContexts& includes);
 
 /**
  * Try to look up the first reachable forward declaration for type @a type
  *
  * @param context The context where this search is happening
  * @param cursor The location from which we're searching
  */
 KDevelop::DeclarationPointer findForwardDeclaration(CXType type, KDevelop::DUContext* context, CXCursor cursor);
 
 /**
  * Wrapper for @ref clang_Cursor_getSpellingNameRange which sometimes reports invalid ranges
  */
 KDevelop::RangeInRevision cursorSpellingNameRange(CXCursor cursor, const KDevelop::Identifier& id);
 
 /**
  * @returns all the Imports for each file in the @a tu
  */
 KDEVCLANGPRIVATE_EXPORT Imports tuImports(CXTranslationUnit tu);
 
 /**
  * Recursively builds a duchain with the specified @a features for the
  * @a file and each of its @a imports using the TU from @a session.
  * The resulting contexts are placed in @a includedFiles.
  * @returns the context created for @a file
  */
 KDEVCLANGPRIVATE_EXPORT KDevelop::ReferencedTopDUContext buildDUChain(
     CXFile file, const Imports& imports, const ParseSession& session,
     KDevelop::TopDUContext::Features features, IncludeFileContexts& includedFiles,
     ClangIndex* index = nullptr, const std::function<bool()>& abortFunction = {});
 
 /**
  * @return List of possible header extensions used for definition/declaration fallback switching
  */
 QStringList headerExtensions();
 
 /**
  * @return List of possible source extensions used for definition/declaration fallback switching
  */
 QStringList sourceExtensions();
 
 /**
  * @return True if the given file @a path has the extension of a C++ source file
  */
 KDEVCLANGPRIVATE_EXPORT bool isSource(const QString& path);
 
 /**
  * @return True if the given file @a path has the extension of a C++ header file
  */
 KDEVCLANGPRIVATE_EXPORT bool isHeader(const QString& path);
 
+KDEVCLANGPRIVATE_EXPORT QString clangVersion();
+
 /**
  * @return The path containing Clang built includes (e.g. stddef.h, stdarg.h, cpuid.h)
  *
  * Also see: https://clang.llvm.org/docs/FAQ.html
  */
 KDEVCLANGPRIVATE_EXPORT QString clangBuiltinIncludePath();
 
 }
 
 #endif //CLANGHELPERS_H