diff --git a/plugins/clang/clangsupport.cpp b/plugins/clang/clangsupport.cpp
index 73a7e406f9..8721bc93d3 100644
--- a/plugins/clang/clangsupport.cpp
+++ b/plugins/clang/clangsupport.cpp
@@ -1,427 +1,437 @@
 /*
     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/clangindex.h"
 #include "duchain/navigationwidget.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()) {
         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)
 {
+    {
+        const auto builtinDir = ClangIntegration::DUChainUtils::clangBuiltinIncludePath();
+        if (!QFile::exists(builtinDir + QLatin1String("/varargs.h"))) {
+            setErrorDescription(i18n("The clang builtin include path \"%1\" is invalid (missing varargs.h 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));
+            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() );
     // TODO: use direct signal/slot connect syntax for 5.1
     connect(model, &CodeCompletion::registeredToView,
             this, &ClangSupport::disableKeywordCompletion);
     connect(model, &CodeCompletion::unregisteredFromView,
             this, &ClangSupport::enableKeywordCompletion);
     for(const auto& type : DocumentFinderHelpers::mimeTypesList()){
         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();
 
     for(const auto& type : DocumentFinderHelpers::mimeTypesList()) {
         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::getPotentialBuddies(const QUrl &url) const
 {
     return DocumentFinderHelpers::getPotentialBuddies(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/duchainutils.cpp b/plugins/clang/duchain/duchainutils.cpp
index ef67fac118..4ffa51955a 100644
--- a/plugins/clang/duchain/duchainutils.cpp
+++ b/plugins/clang/duchain/duchainutils.cpp
@@ -1,105 +1,112 @@
 /*
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) 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 "duchainutils.h"
 
 #include "util/clangdebug.h"
 
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/ducontext.h>
 #include <language/duchain/functiondefinition.h>
 #include <language/duchain/types/typeregister.h>
 
 #include "macrodefinition.h"
 #include "clangducontext.h"
 #include "clangparsingenvironmentfile.h"
 #include "types/classspecializationtype.h"
 
+#include "libclang_include_path.h"
+
 using namespace KDevelop;
 
 namespace ClangIntegration {
 
 KTextEditor::Range DUChainUtils::functionSignatureRange(const Declaration* decl)
 {
     if (!decl->isFunctionDeclaration()) {
         qCWarning(KDEV_CLANG) << "Invalid declaration:" << decl;
         return {};
     }
 
     auto functionContext = decl->internalContext();
     Q_ASSERT(functionContext);
     auto childContexts = functionContext->childContexts();
     if (childContexts.isEmpty()) {
         return functionContext->rangeInCurrentRevision();
     }
 
     const auto start = functionContext->rangeInCurrentRevision().start();
     const auto end = childContexts[0]->rangeInCurrentRevision().start();
     return {start, end};
 }
 
 void DUChainUtils::registerDUChainItems()
 {
     duchainRegisterType<ClangTopDUContext>();
     duchainRegisterType<ClangParsingEnvironmentFile>();
     duchainRegisterType<ClangNormalDUContext>();
     duchainRegisterType<MacroDefinition>();
 
     TypeSystem::self().registerTypeClass<ClassSpecializationType, ClassSpecializationTypeData>();
 }
 
 void DUChainUtils::unregisterDUChainItems()
 {
     TypeSystem::self().unregisterTypeClass<ClassSpecializationType, ClassSpecializationTypeData>();
 
     /// FIXME: this is currently not supported by the DUChain code...
     /// When the items are unregistered on plugin destruction, we'll get hit by
     /// assertions later on when the DUChain is finalized. There, when the data is getting cleaned up,
     /// we try to load all kinds of items again which would fail to find our items if we unregister.
     /// So let's not do it...
 /*
     duchainUnregisterType<ClangTopDUContext>();
     duchainUnregisterType<ClangParsingEnvironmentFile>();
     duchainUnregisterType<ClangNormalDUContext>();
     duchainUnregisterType<MacroDefinition>();
 
 */
 }
 
 ParseSessionData::Ptr DUChainUtils::findParseSessionData(const IndexedString &file, const IndexedString &tufile)
 {
     DUChainReadLocker lock;
     auto context = KDevelop::DUChainUtils::standardContextForUrl(file.toUrl());
     if (!context || !context->ast()) {
         // no cached data found for the current file, but maybe
         // we are lucky and can grab it from the TU context
         // this happens e.g. when originally a .cpp file is open and then one
         // of its included files is opened in the editor.
         context = KDevelop::DUChainUtils::standardContextForUrl(tufile.toUrl());
     }
 
     if (context) {
         return ParseSessionData::Ptr(dynamic_cast<ParseSessionData*>(context->ast().data()));
     }
     return {};
 }
 
+QString DUChainUtils::clangBuiltinIncludePath()
+{
+    return qEnvironmentVariable("KDEV_CLANG_BUILTIN_DIR", QStringLiteral(KDEV_CLANG_BUILTIN_DIR));
+}
+
 }
diff --git a/plugins/clang/duchain/duchainutils.h b/plugins/clang/duchain/duchainutils.h
index 83e9381dea..79b25469e2 100644
--- a/plugins/clang/duchain/duchainutils.h
+++ b/plugins/clang/duchain/duchainutils.h
@@ -1,56 +1,57 @@
 /*
  * Copyright 2014  Kevin Funk <kfunk@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) 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 DUCHAINUTILS_H
 #define DUCHAINUTILS_H
 
 #include "clangprivateexport.h"
 
 #include "duchain/parsesession.h"
 
 namespace KTextEditor {
 class Range;
 }
 
 namespace KDevelop {
 class Declaration;
 }
 
 namespace ClangIntegration {
 namespace DUChainUtils
 {
 
 KDEVCLANGPRIVATE_EXPORT KTextEditor::Range functionSignatureRange(const KDevelop::Declaration* decl);
 
 KDEVCLANGPRIVATE_EXPORT void registerDUChainItems();
 KDEVCLANGPRIVATE_EXPORT void unregisterDUChainItems();
 
 /**
  * Finds attached parse session data (aka AST) to the @p file
  *
  * If no session data found, then @p tuFile asked for the attached session data
  */
 KDEVCLANGPRIVATE_EXPORT ParseSessionData::Ptr findParseSessionData(const KDevelop::IndexedString &file, const KDevelop::IndexedString &tufile);
 
+KDEVCLANGPRIVATE_EXPORT QString clangBuiltinIncludePath();
 };
 
 }
 
 #endif // DUCHAINUTILS_H
diff --git a/plugins/clang/duchain/parsesession.cpp b/plugins/clang/duchain/parsesession.cpp
index 63973e89f0..acd583f59b 100644
--- a/plugins/clang/duchain/parsesession.cpp
+++ b/plugins/clang/duchain/parsesession.cpp
@@ -1,534 +1,535 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
     Copyright 2013 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 "parsesession.h"
 #include <QStandardPaths>
 #include "clangproblem.h"
 #include "clangdiagnosticevaluator.h"
 #include "todoextractor.h"
 #include "clanghelpers.h"
 #include "clangindex.h"
 #include "clangparsingenvironment.h"
+#include "duchainutils.h"
 #include "util/clangdebug.h"
 #include "util/clangtypes.h"
 #include "util/clangutils.h"
-#include "libclang_include_path.h"
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 
 #include <KShell>
 
 #include <QDir>
 #include <QFileInfo>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace {
 
 QVector<QByteArray> extraArgs()
 {
     const auto extraArgsString = QString::fromLatin1(qgetenv("KDEV_CLANG_EXTRA_ARGUMENTS"));
     const auto extraArgs = KShell::splitArgs(extraArgsString);
 
     // transform to list of QByteArrays
     QVector<QByteArray> result;
     result.reserve(extraArgs.size());
     foreach (const QString& arg, extraArgs) {
         result << arg.toLatin1();
     }
     clangDebug() << "Passing extra arguments to clang:" << result;
 
     return result;
 }
 
 void sanitizeArguments(QVector<QByteArray>& arguments)
 {
     // We remove the -Werror flag, and replace -Werror=foo by -Wfoo.
     // Warning as error may cause problem to the clang parser.
     const auto asError = QByteArrayLiteral("-Werror=");
     const auto documentation = QByteArrayLiteral("-Wdocumentation");
     for (auto& argument : arguments) {
         if (argument == "-Werror") {
             argument.clear();
         } else if (argument.startsWith(asError)) {
             // replace -Werror=foo by -Wfoo
             argument.remove(2, asError.length() - 2);
         }
 #if CINDEX_VERSION_MINOR < 100 // FIXME https://bugs.llvm.org/show_bug.cgi?id=35333
         if (argument == documentation) {
             argument.clear();
         }
 #endif
     }
 
 }
 
 QVector<QByteArray> argsForSession(const QString& path, ParseSessionData::Options options, const ParserSettings& parserSettings)
 {
     QMimeDatabase db;
     if(db.mimeTypeForFile(path).name() == QStringLiteral("text/x-objcsrc")) {
         return {QByteArrayLiteral("-xobjective-c++")};
     }
 
     // TODO: No proper mime type detection possible yet
     // cf. https://bugs.freedesktop.org/show_bug.cgi?id=26913
     if (path.endsWith(QLatin1String(".cl"), Qt::CaseInsensitive)) {
         return {QByteArrayLiteral("-xcl")};
     }
 
     // TODO: No proper mime type detection possible yet
     // cf. https://bugs.freedesktop.org/show_bug.cgi?id=23700
     if (path.endsWith(QLatin1String(".cu"), Qt::CaseInsensitive)) {
         return {QByteArrayLiteral("-xcuda")};
     }
 
     if (parserSettings.parserOptions.isEmpty()) {
         // The parserOptions can be empty for some unit tests that use ParseSession directly
         auto defaultArguments = ClangSettingsManager::self()->parserSettings(path).toClangAPI();
 
         defaultArguments.append(QByteArrayLiteral("-nostdinc"));
         defaultArguments.append(QByteArrayLiteral("-nostdinc++"));
         defaultArguments.append(QByteArrayLiteral("-xc++"));
 
         sanitizeArguments(defaultArguments);
         return defaultArguments;
     }
 
     auto result = parserSettings.toClangAPI();
     result.append(QByteArrayLiteral("-nostdinc"));
     if (parserSettings.isCpp()) {
         result.append(QByteArrayLiteral("-nostdinc++"));
     }
 
     if (options & ParseSessionData::PrecompiledHeader) {
         result.append(parserSettings.isCpp() ? QByteArrayLiteral("-xc++-header") : QByteArrayLiteral("-xc-header"));
 
         sanitizeArguments(result);
         return result;
     }
 
     result.append(parserSettings.isCpp() ? QByteArrayLiteral("-xc++") : QByteArrayLiteral("-xc"));
 
     sanitizeArguments(result);
     return result;
 }
 
 void addIncludes(QVector<const char*>* args, QVector<QByteArray>* otherArgs,
                  const Path::List& includes, const char* cliSwitch)
 {
     foreach (const Path& url, includes) {
         if (url.isEmpty()) {
             continue;
         }
         
         QFileInfo info(url.toLocalFile());
         QByteArray path = url.toLocalFile().toUtf8();
 
         if (info.isFile()) {
             path.prepend("-include");
         } else {
             path.prepend(cliSwitch);
         }
         otherArgs->append(path);
         args->append(path.constData());
     }
 }
 
 void addFrameworkDirectories(QVector<const char*>* args, QVector<QByteArray>* otherArgs,
                  const Path::List& frameworkDirectories, const char* cliSwitch)
 {
     foreach (const Path& url, frameworkDirectories) {
         if (url.isEmpty()) {
             continue;
         }
 
         QFileInfo info(url.toLocalFile());
         if (!info.isDir()) {
             qCWarning(KDEV_CLANG) << "supposed framework directory is not a directory:" << url.pathOrUrl();
             continue;
         }
         QByteArray path = url.toLocalFile().toUtf8();
 
         otherArgs->append(cliSwitch);
         otherArgs->append(path);
         args->append(cliSwitch);
         args->append(path.constData());
     }
 }
 
 QVector<CXUnsavedFile> toClangApi(const QVector<UnsavedFile>& unsavedFiles)
 {
     QVector<CXUnsavedFile> unsaved;
     unsaved.reserve(unsavedFiles.size());
     std::transform(unsavedFiles.begin(), unsavedFiles.end(),
                 std::back_inserter(unsaved),
                 [] (const UnsavedFile& file) { return file.toClangApi(); });
     return unsaved;
 }
 
 bool hasQtIncludes(const Path::List& includePaths)
 {
     return std::find_if(includePaths.begin(), includePaths.end(), [] (const Path& path) {
         return path.lastPathSegment() == QLatin1String("QtCore");
     }) != includePaths.end();
 }
 
 }
 
 ParseSessionData::ParseSessionData(const QVector<UnsavedFile>& unsavedFiles, ClangIndex* index,
                                    const ClangParsingEnvironment& environment, Options options)
     : m_file(nullptr)
     , m_unit(nullptr)
 {
     unsigned int flags = CXTranslationUnit_DetailedPreprocessingRecord
 #if CINDEX_VERSION_MINOR >= 34
         | CXTranslationUnit_KeepGoing
 #endif
     ;
     if (options.testFlag(SkipFunctionBodies)) {
         flags |= CXTranslationUnit_SkipFunctionBodies;
     }
     if (options.testFlag(PrecompiledHeader)) {
         flags |= CXTranslationUnit_ForSerialization;
     } else {
         flags |= CXTranslationUnit_CacheCompletionResults
 #if CINDEX_VERSION_MINOR >= 32
               |  CXTranslationUnit_CreatePreambleOnFirstParse
 #endif
               |  CXTranslationUnit_PrecompiledPreamble;
         if (environment.quality() == ClangParsingEnvironment::Unknown) {
             flags |= CXTranslationUnit_Incomplete;
         }
     }
 
     const auto tuUrl = environment.translationUnitUrl();
     Q_ASSERT(!tuUrl.isEmpty());
 
     const auto arguments = argsForSession(tuUrl.str(), options, environment.parserSettings());
     QVector<const char*> clangArguments;
 
     const auto& includes = environment.includes();
     const auto& pchInclude = environment.pchInclude();
 
     // uses QByteArray as smart-pointer for const char* ownership
     QVector<QByteArray> smartArgs;
     smartArgs.reserve(includes.system.size() + includes.project.size()
                       + pchInclude.isValid() + arguments.size() + 1);
     clangArguments.reserve(smartArgs.size());
 
     std::transform(arguments.constBegin(), arguments.constEnd(),
                    std::back_inserter(clangArguments),
                    [] (const QByteArray &argument) { return argument.constData(); });
 
     // NOTE: the PCH include must come before all other includes!
     if (pchInclude.isValid()) {
         clangArguments << "-include";
         QByteArray pchFile = pchInclude.toLocalFile().toUtf8();
         smartArgs << pchFile;
         clangArguments << pchFile.constData();
     }
 
     if (hasQtIncludes(includes.system)) {
         const auto wrappedQtHeaders = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                              QStringLiteral("kdevclangsupport/wrappedQtHeaders"),
                                                              QStandardPaths::LocateDirectory).toUtf8();
         if (!wrappedQtHeaders.isEmpty()) {
             smartArgs << wrappedQtHeaders;
             clangArguments << "-isystem" << wrappedQtHeaders.constData();
             const QByteArray qtCore = wrappedQtHeaders + "/QtCore";
             smartArgs << qtCore;
             clangArguments << "-isystem" << qtCore.constData();
         }
     }
 
     addIncludes(&clangArguments, &smartArgs, includes.system, "-isystem");
     addIncludes(&clangArguments, &smartArgs, includes.project, "-I");
 
     const auto& frameworkDirectories = environment.frameworkDirectories();
     addFrameworkDirectories(&clangArguments, &smartArgs, frameworkDirectories.system, "-iframework");
     addFrameworkDirectories(&clangArguments, &smartArgs, frameworkDirectories.project, "-F");
 
     // libclang cannot find it's builtin dir automatically, we have to specify it manually
-    clangArguments << "-isystem" << KDEV_CLANG_BUILTIN_DIR;
+    smartArgs << ClangIntegration::DUChainUtils::clangBuiltinIncludePath().toUtf8();
+    clangArguments << "-isystem" << smartArgs.last().constData();
 
     smartArgs << writeDefinesFile(environment.defines());
     clangArguments << "-imacros" << smartArgs.last().constData();
 
     // append extra args from environment variable
     static const auto extraArgs = ::extraArgs();
     foreach (const QByteArray& arg, extraArgs) {
         clangArguments << arg.constData();
     }
 
     QVector<CXUnsavedFile> unsaved;
     //For PrecompiledHeader, we don't want unsaved contents (and contents.isEmpty())
     if (!options.testFlag(PrecompiledHeader)) {
         unsaved = toClangApi(unsavedFiles);
     }
 
     // debugging: print hypothetical clang invocation including args (for easy c&p for local testing)
     if (qEnvironmentVariableIsSet("KDEV_CLANG_DISPLAY_ARGS")) {
         QTextStream out(stdout);
         out << "Invocation: clang";
         foreach (const auto& arg, clangArguments) {
             out << " " << arg;
         }
         out << " " << tuUrl.byteArray().constData() << "\n";
     }
 
     const CXErrorCode code = clang_parseTranslationUnit2(
         index->index(), tuUrl.byteArray().constData(),
         clangArguments.constData(), clangArguments.size(),
         unsaved.data(), unsaved.size(),
         flags,
         &m_unit
     );
     if (code != CXError_Success) {
         qCWarning(KDEV_CLANG) << "clang_parseTranslationUnit2 return with error code" << code;
         if (!qEnvironmentVariableIsSet("KDEV_CLANG_DISPLAY_DIAGS")) {
             qCWarning(KDEV_CLANG) << "  (start KDevelop with `KDEV_CLANG_DISPLAY_DIAGS=1 kdevelop` to see more diagnostics)";
         }
     }
 
     if (m_unit) {
         setUnit(m_unit);
         m_environment = environment;
 
         if (options.testFlag(PrecompiledHeader)) {
             clang_saveTranslationUnit(m_unit, QByteArray(tuUrl.byteArray() + ".pch").constData(), CXSaveTranslationUnit_None);
         }
     } else {
         qCWarning(KDEV_CLANG) << "Failed to parse translation unit:" << tuUrl;
     }
 }
 
 ParseSessionData::~ParseSessionData()
 {
     clang_disposeTranslationUnit(m_unit);
 }
 
 QByteArray ParseSessionData::writeDefinesFile(const QMap<QString, QString>& defines)
 {
     m_definesFile.open();
     Q_ASSERT(m_definesFile.isWritable());
 
     {
         QTextStream definesStream(&m_definesFile);
         // don't show warnings about redefined macros
         definesStream << "#pragma clang system_header\n";
         for (auto it = defines.begin(); it != defines.end(); ++it) {
             if (it.key().startsWith(QLatin1String("__has_include("))
                 || it.key().startsWith(QLatin1String("__has_include_next(")))
             {
                 continue;
             }
             definesStream << QStringLiteral("#define ") << it.key() << ' ' << it.value() << '\n';
         }
     }
     m_definesFile.close();
 
     if (qEnvironmentVariableIsSet("KDEV_CLANG_DISPLAY_DEFINES")) {
         QFile f(m_definesFile.fileName());
         f.open(QIODevice::ReadOnly);
         Q_ASSERT(f.isReadable());
         QTextStream out(stdout);
         out << "Defines file: " << f.fileName() << "\n"
             << f.readAll() << f.size()
             << "\n VS defines:" << defines.size() << "\n";
     }
 
     return m_definesFile.fileName().toUtf8();
 }
 
 void ParseSessionData::setUnit(CXTranslationUnit unit)
 {
     m_unit = unit;
     m_diagnosticsCache.clear();
     if (m_unit) {
         const ClangString unitFile(clang_getTranslationUnitSpelling(unit));
         m_file = clang_getFile(m_unit, unitFile.c_str());
     } else {
         m_file = nullptr;
     }
 }
 
 ClangParsingEnvironment ParseSessionData::environment() const
 {
     return m_environment;
 }
 
 ParseSession::ParseSession(const ParseSessionData::Ptr& data)
     : d(data)
 {
     if (d) {
         ENSURE_CHAIN_NOT_LOCKED
         d->m_mutex.lock();
     }
 }
 
 ParseSession::~ParseSession()
 {
     if (d) {
         d->m_mutex.unlock();
     }
 }
 
 void ParseSession::setData(const ParseSessionData::Ptr& data)
 {
     if (data == d) {
         return;
     }
 
     if (d) {
         d->m_mutex.unlock();
     }
 
     d = data;
 
     if (d) {
         ENSURE_CHAIN_NOT_LOCKED
         d->m_mutex.lock();
     }
 }
 
 ParseSessionData::Ptr ParseSession::data() const
 {
     return d;
 }
 
 IndexedString ParseSession::languageString()
 {
     static const IndexedString lang("Clang");
     return lang;
 }
 
 QList<ProblemPointer> ParseSession::problemsForFile(CXFile file) const
 {
     if (!d) {
         return {};
     }
 
     QList<ProblemPointer> problems;
 
     // extra clang diagnostics
     const uint numDiagnostics = clang_getNumDiagnostics(d->m_unit);
     problems.reserve(numDiagnostics);
     d->m_diagnosticsCache.resize(numDiagnostics);
 
     for (uint i = 0; i < numDiagnostics; ++i) {
         auto diagnostic = clang_getDiagnostic(d->m_unit, i);
 
         CXSourceLocation location = clang_getDiagnosticLocation(diagnostic);
         CXFile diagnosticFile;
         clang_getFileLocation(location, &diagnosticFile, nullptr, nullptr, nullptr);
         // missing-include problems are so severe in clang that we always propagate
         // them to this document, to ensure that the user will see the error.
         if (diagnosticFile != file && ClangDiagnosticEvaluator::diagnosticType(diagnostic) != ClangDiagnosticEvaluator::IncludeFileNotFoundProblem) {
             continue;
         }
 
         auto& problem = d->m_diagnosticsCache[i];
         if (!problem) {
             problem = ClangDiagnosticEvaluator::createProblem(diagnostic, d->m_unit);
         }
 
         problems << problem;
 
         clang_disposeDiagnostic(diagnostic);
     }
 
     // other problem sources
 
     TodoExtractor extractor(unit(), file);
     problems << extractor.problems();
 
 #if CINDEX_VERSION_MINOR > 30
     // note that the below warning is triggered on every reparse when there is a precompiled preamble
     // see also TestDUChain::testReparseIncludeGuard
     const QString path = QDir(ClangString(clang_getFileName(file)).toString()).canonicalPath();
     const IndexedString indexedPath(path);
     if (ClangHelpers::isHeader(path) && !clang_isFileMultipleIncludeGuarded(unit(), file)
         && !clang_Location_isInSystemHeader(clang_getLocationForOffset(d->m_unit, file, 0)))
     {
         ProblemPointer problem(new Problem);
         problem->setSeverity(IProblem::Warning);
         problem->setDescription(i18n("Header is not guarded against multiple inclusions"));
         problem->setExplanation(i18n("The given header is not guarded against multiple inclusions, "
             "either with the conventional #ifndef/#define/#endif macro guards or with #pragma once."));
         problem->setFinalLocation({indexedPath, KTextEditor::Range()});
         problem->setSource(IProblem::Preprocessor);
         problems << problem;
         // TODO: Easy to add an assistant here that adds the guards -- any takers?
     }
 #endif
 
     return problems;
 }
 
 CXTranslationUnit ParseSession::unit() const
 {
     return d ? d->m_unit : nullptr;
 }
 
 CXFile ParseSession::file(const QByteArray& path) const
 {
     return clang_getFile(unit(), path.constData());
 }
 
 CXFile ParseSession::mainFile() const
 {
     return d ? d->m_file : nullptr;
 }
 
 bool ParseSession::reparse(const QVector<UnsavedFile>& unsavedFiles, const ClangParsingEnvironment& environment)
 {
     if (!d || environment != d->m_environment) {
         return false;
     }
 
     auto unsaved = toClangApi(unsavedFiles);
 
     const auto code = clang_reparseTranslationUnit(d->m_unit, unsaved.size(), unsaved.data(),
                                                    clang_defaultReparseOptions(d->m_unit));
     if (code != CXError_Success) {
         qCWarning(KDEV_CLANG) << "clang_reparseTranslationUnit return with error code" << code;
         // if error code != 0 => clang_reparseTranslationUnit invalidates the old translation unit => clean up
         clang_disposeTranslationUnit(d->m_unit);
         d->setUnit(nullptr);
         return false;
     }
 
     // update state
     d->setUnit(d->m_unit);
     return true;
 }
 
 ClangParsingEnvironment ParseSession::environment() const
 {
     return d->m_environment;
 }