diff --git a/languages/clang/duchain/parsesession.cpp b/languages/clang/duchain/parsesession.cpp
index cd8d7ba8a6..49c6b062d9 100644
--- a/languages/clang/duchain/parsesession.cpp
+++ b/languages/clang/duchain/parsesession.cpp
@@ -1,344 +1,350 @@
 /*
     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 "clangproblem.h"
 #include "clangdiagnosticevaluator.h"
 #include "todoextractor.h"
 #include "clanghelpers.h"
 #include "clangindex.h"
 #include "clangparsingenvironment.h"
 #include "util/clangdebug.h"
 #include "util/clangtypes.h"
 #include "util/clangutils.h"
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 
 #include <QDir>
 #include <QFileInfo>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace {
 
 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++")};
     }
 
+    // this can happen for unit tests that use the ParseSession directly
     if (parserSettings.parserOptions.isEmpty()) {
-        // this can happen for unit tests that use the ParseSession directly
-        auto defaultArguments = ClangSettingsManager::self()->parserSettings(nullptr).toClangAPI();
-        Q_ASSERT(!defaultArguments.isEmpty());
-        defaultArguments.append(QByteArrayLiteral("-nostdinc"));
-        defaultArguments.append(QByteArrayLiteral("-nostdinc++"));
-        defaultArguments.append(QByteArrayLiteral("-xc++"));
-        return defaultArguments;
+        return {
+            QByteArrayLiteral("-fspell-checking"),
+            QByteArrayLiteral("-Wdocumentation"),
+            QByteArrayLiteral("-std=c++11"),
+            QByteArrayLiteral("-xc++"),
+            QByteArrayLiteral("-Wall"),
+            QByteArrayLiteral("-Wunused-parameter"),
+            QByteArrayLiteral("-Wunreachable-code"),
+            QByteArrayLiteral("-nostdinc"),
+            QByteArrayLiteral("-nostdinc++"),
+            QByteArrayLiteral("-ferror-limit=100")
+        };
     }
 
     auto result = parserSettings.toClangAPI();
     result.append(QByteArrayLiteral("-nostdinc"));
     result.append(QByteArrayLiteral("-nostdinc++"));
 
     if (options & ParseSessionData::PrecompiledHeader) {
         result.append(parserSettings.isCpp() ? QByteArrayLiteral("-xc++-header") : QByteArrayLiteral("-xc-header"));
         return result;
     }
 
     result.append(parserSettings.isCpp() ? QByteArrayLiteral("-xc++") : QByteArrayLiteral("-xc"));
     return result;
 }
 
 void addIncludes(QVector<const char*>* args, QVector<QByteArray>* otherArgs,
                  const Path::List& includes, const char* cliSwitch)
 {
     foreach (const Path& url, includes) {
         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());
     }
 }
 
 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;
 }
 
 }
 
 ParseSessionData::ParseSessionData(const QVector<UnsavedFile>& unsavedFiles, ClangIndex* index,
                                    const ClangParsingEnvironment& environment, Options options)
     : m_file(nullptr)
     , m_unit(nullptr)
 {
     unsigned int flags = CXTranslationUnit_CXXChainedPCH
         | CXTranslationUnit_DetailedPreprocessingRecord;
     if (options.testFlag(SkipFunctionBodies)) {
         flags |= CXTranslationUnit_SkipFunctionBodies;
     }
     if (options.testFlag(PrecompiledHeader)) {
         flags |= CXTranslationUnit_ForSerialization;
     } else {
         flags |= CXTranslationUnit_CacheCompletionResults
               |  CXTranslationUnit_PrecompiledPreamble
               |  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();
     }
     addIncludes(&clangArguments, &smartArgs, includes.system, "-isystem");
     addIncludes(&clangArguments, &smartArgs, includes.project, "-I");
 
     m_definesFile.open();
     QTextStream definesStream(&m_definesFile);
     Q_ASSERT(m_definesFile.isWritable());
     const auto& defines = environment.defines();
     for (auto it = defines.begin(); it != defines.end(); ++it) {
         definesStream << QStringLiteral("#define ") << it.key() << ' ' << it.value() << '\n';
     }
     definesStream.flush();
     smartArgs << m_definesFile.fileName().toUtf8();
     clangArguments << "-imacros" << smartArgs.last().constData();
 
     QVector<CXUnsavedFile> unsaved;
     //For PrecompiledHeader, we don't want unsaved contents (and contents.isEmpty())
     if (!options.testFlag(PrecompiledHeader)) {
         unsaved = toClangApi(unsavedFiles);
     }
 
     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) {
         qWarning() << "clang_parseTranslationUnit2 return with error code" << code;
     }
 
     if (m_unit) {
         setUnit(m_unit);
         m_environment = environment;
 
         if (options.testFlag(PrecompiledHeader)) {
             clang_saveTranslationUnit(m_unit, (tuUrl.byteArray() + ".pch").constData(), CXSaveTranslationUnit_None);
         }
     } else {
         qWarning() << "Failed to parse translation unit:" << tuUrl;
     }
 }
 
 ParseSessionData::~ParseSessionData()
 {
     clang_disposeTranslationUnit(m_unit);
 }
 
 void ParseSessionData::setUnit(CXTranslationUnit unit)
 {
     Q_ASSERT(!m_unit || unit == m_unit);
 
     m_unit = unit;
     const ClangString unitFile(clang_getTranslationUnitSpelling(unit));
     m_file = clang_getFile(m_unit, unitFile.c_str());
 }
 
 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);
     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);
         if (diagnosticFile != file) {
             continue;
         }
 
         ProblemPointer problem(ClangDiagnosticEvaluator::createProblem(diagnostic, d->m_unit));
         problems << problem;
 
         clang_disposeDiagnostic(diagnostic);
     }
 
     const QString path = QDir(ClangString(clang_getFileName(file)).toString()).canonicalPath();
     const IndexedString indexedPath(path);
 
     TodoExtractor extractor(unit(), file);
     problems << extractor.problems();
 
     // other problem sources
     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?
     }
 
     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);
 
     if (clang_reparseTranslationUnit(d->m_unit, unsaved.size(), unsaved.data(), clang_defaultReparseOptions(d->m_unit)) == 0) {
         d->setUnit(d->m_unit);
         return true;
     } else {
         return false;
     }
 }
 
 ClangParsingEnvironment ParseSession::environment() const
 {
     return d->m_environment;
 }
diff --git a/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp b/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp
index f433cc1696..674b5e22da 100644
--- a/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp
+++ b/languages/plugins/custom-definesandincludes/compilerprovider/settingsmanager.cpp
@@ -1,347 +1,347 @@
 /*
  * This file is part of KDevelop
  *
  * Copyright 2010 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2014 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) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along
  * with this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  */
 
 #include "settingsmanager.h"
 
 #include <QDataStream>
 #include <QDebug>
 #include <QThread>
 #include <QCoreApplication>
 
 #include <KConfig>
 #include <KConfigGroup>
 
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <project/projectmodel.h>
 
 #include "compilerprovider.h"
 
 using namespace KDevelop;
 
 namespace {
 namespace ConfigConstants {
 const QString configKey = QLatin1String( "CustomDefinesAndIncludes" );
 const QString definesKey = QLatin1String( "Defines" );
 const QString includesKey = QLatin1String( "Includes" );
 const QString projectPathPrefix = QLatin1String( "ProjectPath" );
 const QString projectPathKey = QLatin1String( "Path" );
 
 const QString customBuildSystemGroup = QLatin1String( "CustomBuildSystem" );
 const QString definesAndIncludesGroup = QLatin1String( "Defines And Includes" );
 
 const QString compilersGroup = QLatin1String( "Compilers" );
 const QString compilerNameKey = QLatin1String( "Name" );
 const QString compilerPathKey = QLatin1String( "Path" );
 const QString compilerTypeKey = QLatin1String( "Type" );
 
 QString parserArguments(){ return QStringLiteral("parserArguments"); }
 }
 
 // the grouplist is randomly sorted b/c it uses QSet internally
 // we sort the keys here, as the structure is properly defined for us
 QStringList sorted(QStringList list)
 {
     std::sort(list.begin(), list.end());
     return list;
 }
 
-QString defaultArguments(){ return QStringLiteral("-ferror-limit=100 -fspell-checking -Wdocumentation -Wunused-parameter -Wunreachable-code -Wall -std=c++11"); }
+QString defaultArguments(){ return QStringLiteral("-fspell-checking -Wdocumentation -std=c++11 -Wall"); }
 
 CompilerPointer createCompilerFromConfig(KConfigGroup& cfg)
 {
     auto grp = cfg.group("Compiler");
     auto name = grp.readEntry( ConfigConstants::compilerNameKey, QString() );
     if (name.isEmpty()) {
         return SettingsManager::globalInstance()->provider()->checkCompilerExists({});
     }
 
     for (auto c : SettingsManager::globalInstance()->provider()->compilers()) {
         if (c->name() == name) {
             return c;
         }
     }
 
     // Otherwise we have no such compiler registered (broken config file), return default one
     return SettingsManager::globalInstance()->provider()->checkCompilerExists({});
 }
 
 void writeCompilerToConfig(KConfigGroup& cfg, const CompilerPointer& compiler)
 {
     Q_ASSERT(compiler);
 
     auto grp = cfg.group("Compiler");
     // Store only compiler name, path and type retrieved from registered compilers
     grp.writeEntry(ConfigConstants::compilerNameKey, compiler->name());
 }
 
 void doWriteSettings( KConfigGroup grp, const QList<ConfigEntry>& paths )
 {
     int pathIndex = 0;
     for ( const auto& path : paths ) {
         KConfigGroup pathgrp = grp.group( ConfigConstants::projectPathPrefix + QString::number( pathIndex++ ) );
         pathgrp.writeEntry(ConfigConstants::projectPathKey, path.path);
         pathgrp.writeEntry(ConfigConstants::parserArguments(), path.parserArguments);
 
         {
             int index = 0;
             KConfigGroup includes(pathgrp.group(ConfigConstants::includesKey));
             for( auto it = path.includes.begin() ; it != path.includes.end(); ++it){
                 includes.writeEntry(QString::number(++index), *it);
             }
 
         }
         {
             KConfigGroup defines(pathgrp.group(ConfigConstants::definesKey));
             for (auto it = path.defines.begin(); it != path.defines.end(); ++it) {
                 defines.writeEntry(it.key(), it.value());
             }
         }
         writeCompilerToConfig(pathgrp, path.compiler);
     }
 }
 
 /// @param remove if true all read entries will be removed from the config file
 QList<ConfigEntry> doReadSettings( KConfigGroup grp, bool remove = false )
 {
     QList<ConfigEntry> paths;
     for( const QString &grpName : sorted(grp.groupList()) ) {
         if ( !grpName.startsWith( ConfigConstants::projectPathPrefix ) ) {
             continue;
         }
         KConfigGroup pathgrp = grp.group( grpName );
 
         ConfigEntry path;
         path.path = pathgrp.readEntry( ConfigConstants::projectPathKey, "" );
         path.parserArguments = pathgrp.readEntry(ConfigConstants::parserArguments(), defaultArguments());
 
         { // defines
             // Backwards compatibility with old config style
             if(pathgrp.hasKey(ConfigConstants::definesKey)) {
                 QByteArray tmp = pathgrp.readEntry( ConfigConstants::definesKey, QByteArray() );
                 QDataStream s( tmp );
                 s.setVersion( QDataStream::Qt_4_5 );
                 // backwards compatible reading
                 QHash<QString, QVariant> defines;
                 s >> defines;
                 path.setDefines(defines);
             } else {
                 KConfigGroup defines(pathgrp.group(ConfigConstants::definesKey));
                 QMap<QString, QString> defMap = defines.entryMap();
                 path.defines.reserve(defMap.size());
                 for(auto it = defMap.constBegin(); it != defMap.constEnd(); ++it) {
                     QString key = it.key();
                     if(key.isEmpty()) {
                         // Toss out the invalid key and value since a valid
                         // value needs a valid key
                         continue;
                     } else {
                             path.defines.insert(key, it.value());
                     }
                 }
             }
         }
 
         { // includes
             // Backwards compatibility with old config style
             if(pathgrp.hasKey(ConfigConstants::includesKey)){
                 QByteArray tmp = pathgrp.readEntry( ConfigConstants::includesKey, QByteArray() );
                 QDataStream s( tmp );
                 s.setVersion( QDataStream::Qt_4_5 );
                 s >> path.includes;
             } else {
                 KConfigGroup includes(pathgrp.group(ConfigConstants::includesKey));
                 QMap<QString, QString> incMap = includes.entryMap();
                 for(auto it = incMap.begin(); it != incMap.end(); ++it){
                     QString value = it.value();
                     if(value.isEmpty()){
                         continue;
                     }
                     path.includes += value;
                 }
             }
         }
 
         path.compiler = createCompilerFromConfig(pathgrp);
 
         if ( remove ) {
             pathgrp.deleteGroup();
         }
         paths << path;
     }
 
     return paths;
 }
 
 /**
  * Reads and converts paths from old (Custom Build System's) format to the current one.
  * @return all converted paths (if any)
  */
 QList<ConfigEntry> convertedPaths( KConfig* cfg )
 {
     KConfigGroup group = cfg->group( ConfigConstants::customBuildSystemGroup );
     if ( !group.isValid() )
         return {};
 
     QList<ConfigEntry> paths;
     foreach( const QString &grpName, sorted(group.groupList()) ) {
         KConfigGroup subgroup = group.group( grpName );
         if ( !subgroup.isValid() )
             continue;
 
         paths += doReadSettings( subgroup, true );
     }
 
     return paths;
 }
 
 }
 
 void ConfigEntry::setDefines(const QHash<QString, QVariant>& newDefines)
 {
     defines.clear();
     defines.reserve(newDefines.size());
     for (auto it = newDefines.begin(); it != newDefines.end(); ++it) {
         defines[it.key()] = it.value().toString();
     }
 }
 
 SettingsManager::SettingsManager()
   : m_provider(this)
 {}
 
 SettingsManager::~SettingsManager()
 {}
 
 SettingsManager* SettingsManager::globalInstance()
 {
     Q_ASSERT(QThread::currentThread() == qApp->thread());
     static SettingsManager s_globalInstance;
     return &s_globalInstance;
 }
 
 CompilerProvider* SettingsManager::provider()
 {
     return &m_provider;
 }
 
 const CompilerProvider* SettingsManager::provider() const
 {
     return &m_provider;
 }
 
 void SettingsManager::writePaths( KConfig* cfg, const QList< ConfigEntry >& paths )
 {
     Q_ASSERT(QThread::currentThread() == qApp->thread());
 
     KConfigGroup grp = cfg->group( ConfigConstants::configKey );
     if ( !grp.isValid() )
         return;
 
     grp.deleteGroup();
 
     doWriteSettings( grp, paths );
 }
 
 QList<ConfigEntry> SettingsManager::readPaths( KConfig* cfg ) const
 {
     Q_ASSERT(QThread::currentThread() == qApp->thread());
 
     auto converted = convertedPaths( cfg );
     if ( !converted.isEmpty() ) {
         const_cast<SettingsManager*>(this)->writePaths( cfg, converted );
         return converted;
     }
 
     KConfigGroup grp = cfg->group( ConfigConstants::configKey );
     if ( !grp.isValid() ) {
         return {};
     }
 
     return doReadSettings( grp );
 }
 
 bool SettingsManager::needToReparseCurrentProject( KConfig* cfg ) const
 {
     auto grp = cfg->group( ConfigConstants::definesAndIncludesGroup );
     return grp.readEntry( "reparse", true );
 }
 
 void SettingsManager::writeUserDefinedCompilers(const QVector< CompilerPointer >& compilers)
 {
     QVector< CompilerPointer > editableCompilers;
     for (const auto& compiler : compilers) {
         if (!compiler->editable()) {
             continue;
         }
         editableCompilers.append(compiler);
     }
 
     KConfigGroup config = KSharedConfig::openConfig()->group(ConfigConstants::compilersGroup);
     config.deleteGroup();
     config.writeEntry("number", editableCompilers.count());
     int i = 0;
     for (const auto& compiler : editableCompilers) {
         KConfigGroup grp = config.group(QString::number(i));
         ++i;
 
         grp.writeEntry(ConfigConstants::compilerNameKey, compiler->name());
         grp.writeEntry(ConfigConstants::compilerPathKey, compiler->path());
         grp.writeEntry(ConfigConstants::compilerTypeKey, compiler->factoryName());
     }
     config.sync();
 }
 
 QVector< CompilerPointer > SettingsManager::userDefinedCompilers() const
 {
     QVector< CompilerPointer > compilers;
 
     KConfigGroup config = KSharedConfig::openConfig()->group(ConfigConstants::compilersGroup);
     int count = config.readEntry("number", 0);
     for (int i = 0; i < count; i++) {
         KConfigGroup grp = config.group(QString::number(i));
 
         auto name = grp.readEntry(ConfigConstants::compilerNameKey, QString());
         auto path = grp.readEntry(ConfigConstants::compilerPathKey, QString());
         auto type = grp.readEntry(ConfigConstants::compilerTypeKey, QString());
 
         auto cf = m_provider.compilerFactories();
         for (auto f : cf) {
             if (f->name() == type) {
                 auto compiler = f->createCompiler(name, path);
                 compilers.append(compiler);
             }
         }
     }
     return compilers;
 }
 
 QString SettingsManager::defaultParserArguments() const
 {
     return defaultArguments();
 }
 
 ConfigEntry::ConfigEntry(const QString& path)
     : path(path)
     , compiler(SettingsManager::globalInstance()->provider()->checkCompilerExists({}))
 {}