diff --git a/src/plugins/projectexplorer/msvctoolchain.cpp b/src/plugins/projectexplorer/msvctoolchain.cpp
index 55e6b101bd5..004328c620e 100644
--- a/src/plugins/projectexplorer/msvctoolchain.cpp
+++ b/src/plugins/projectexplorer/msvctoolchain.cpp
@@ -60,10 +60,10 @@
 #include <QFormLayout>
 
 #define KEY_ROOT "ProjectExplorer.MsvcToolChain."
-static const char varsBatKeyC[] = KEY_ROOT"VarsBat";
-static const char varsBatArgKeyC[] = KEY_ROOT"VarsBatArg";
-static const char supportedAbiKeyC[] = KEY_ROOT"SupportedAbi";
-static const char environModsKeyC[] = KEY_ROOT"environmentModifications";
+static const char varsBatKeyC[] = KEY_ROOT "VarsBat";
+static const char varsBatArgKeyC[] = KEY_ROOT "VarsBatArg";
+static const char supportedAbiKeyC[] = KEY_ROOT "SupportedAbi";
+static const char environModsKeyC[] = KEY_ROOT "environmentModifications";
 
 enum { debug = 0 };
 
@@ -84,25 +84,24 @@ static QThreadPool *envModThreadPool()
     return pool;
 }
 
-struct MsvcPlatform {
+struct MsvcPlatform
+{
     MsvcToolChain::Platform platform;
     const char *name;
     const char *prefix; // VS up until 14.0 (MSVC2015)
     const char *bat;
 };
 
-const MsvcPlatform platforms[] =
-{
-    {MsvcToolChain::x86, "x86", "/bin", "vcvars32.bat"},
-    {MsvcToolChain::amd64, "amd64", "/bin/amd64", "vcvars64.bat"},
-    {MsvcToolChain::x86_amd64, "x86_amd64", "/bin/x86_amd64", "vcvarsx86_amd64.bat"},
-    {MsvcToolChain::ia64, "ia64", "/bin/ia64", "vcvars64.bat"},
-    {MsvcToolChain::x86_ia64, "x86_ia64", "/bin/x86_ia64", "vcvarsx86_ia64.bat"},
-    {MsvcToolChain::arm, "arm", "/bin/arm", "vcvarsarm.bat"},
-    {MsvcToolChain::x86_arm, "x86_arm", "/bin/x86_arm", "vcvarsx86_arm.bat"},
-    {MsvcToolChain::amd64_arm, "amd64_arm", "/bin/amd64_arm", "vcvarsamd64_arm.bat"},
-    {MsvcToolChain::amd64_x86, "amd64_x86", "/bin/amd64_x86", "vcvarsamd64_x86.bat"}
-};
+const MsvcPlatform platforms[]
+    = {{MsvcToolChain::x86, "x86", "/bin", "vcvars32.bat"},
+       {MsvcToolChain::amd64, "amd64", "/bin/amd64", "vcvars64.bat"},
+       {MsvcToolChain::x86_amd64, "x86_amd64", "/bin/x86_amd64", "vcvarsx86_amd64.bat"},
+       {MsvcToolChain::ia64, "ia64", "/bin/ia64", "vcvars64.bat"},
+       {MsvcToolChain::x86_ia64, "x86_ia64", "/bin/x86_ia64", "vcvarsx86_ia64.bat"},
+       {MsvcToolChain::arm, "arm", "/bin/arm", "vcvarsarm.bat"},
+       {MsvcToolChain::x86_arm, "x86_arm", "/bin/x86_arm", "vcvarsx86_arm.bat"},
+       {MsvcToolChain::amd64_arm, "amd64_arm", "/bin/amd64_arm", "vcvarsamd64_arm.bat"},
+       {MsvcToolChain::amd64_x86, "amd64_x86", "/bin/amd64_x86", "vcvarsamd64_x86.bat"}};
 
 static QList<const MsvcToolChain *> g_availableMsvcToolchains;
 
@@ -132,7 +131,7 @@ static bool hostSupportsPlatform(MsvcToolChain::Platform platform)
         Q_FALLTHROUGH(); // all x86 toolchains are also working on an amd64 host
     case Utils::HostOsInfo::HostArchitectureX86:
         return platform == MsvcToolChain::x86 || platform == MsvcToolChain::x86_amd64
-                || platform == MsvcToolChain::x86_ia64 || platform == MsvcToolChain::x86_arm;
+               || platform == MsvcToolChain::x86_ia64 || platform == MsvcToolChain::x86_arm;
     case Utils::HostOsInfo::HostArchitectureArm:
         return platform == MsvcToolChain::arm;
     case Utils::HostOsInfo::HostArchitectureItanium:
@@ -154,7 +153,7 @@ struct VisualStudioInstallation
 {
     QString vsName;
     QVersionNumber version;
-    QString path; // Main installation path
+    QString path;       // Main installation path
     QString vcVarsPath; // Path under which the various vc..bat are to be found
     QString vcVarsAll;
 };
@@ -164,10 +163,10 @@ QDebug operator<<(QDebug d, const VisualStudioInstallation &i)
     QDebugStateSaver saver(d);
     d.noquote();
     d.nospace();
-    d << "VisualStudioInstallation(\"" << i.vsName << "\", v=" << i.version
-      << ", path=\"" << QDir::toNativeSeparators(i.path)
-      << "\", vcVarsPath=\"" << QDir::toNativeSeparators(i.vcVarsPath)
-      << "\", vcVarsAll=\"" << QDir::toNativeSeparators(i.vcVarsAll) << "\")";
+    d << "VisualStudioInstallation(\"" << i.vsName << "\", v=" << i.version << ", path=\""
+      << QDir::toNativeSeparators(i.path) << "\", vcVarsPath=\""
+      << QDir::toNativeSeparators(i.vcVarsPath) << "\", vcVarsAll=\""
+      << QDir::toNativeSeparators(i.vcVarsAll) << "\")";
     return d;
 }
 
@@ -182,8 +181,7 @@ static QString windowsProgramFilesDir()
 }
 
 static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
-        const QString &installationPath,
-        const QVersionNumber &version)
+    const QString &installationPath, const QVersionNumber &version)
 {
     QString vcVarsPath = QDir::fromNativeSeparators(installationPath);
     if (!vcVarsPath.endsWith('/'))
@@ -196,8 +194,7 @@ static Utils::optional<VisualStudioInstallation> installationFromPathAndVersion(
     const QString vcVarsAllPath = vcVarsPath + QStringLiteral("/vcvarsall.bat");
     if (!QFileInfo(vcVarsAllPath).isFile()) {
         qWarning().noquote() << "Unable to find MSVC setup script "
-            << QDir::toNativeSeparators(vcVarsPath) << " in version "
-            << version;
+                             << QDir::toNativeSeparators(vcVarsPath) << " in version " << version;
         return Utils::nullopt;
     }
 
@@ -238,8 +235,8 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromVsWhere(const QSt
     Utils::SynchronousProcess vsWhereProcess;
     const int timeoutS = 5;
     vsWhereProcess.setTimeoutS(timeoutS);
-    const QStringList arguments { "-products", "*", "-prerelease", "-legacy", "-format", "json",
-                                  "-utf8"};
+    const QStringList
+        arguments{"-products", "*", "-prerelease", "-legacy", "-format", "json", "-utf8"};
     Utils::SynchronousProcessResponse response = vsWhereProcess.runBlocking(vswhere, arguments);
     switch (response.result) {
     case Utils::SynchronousProcessResponse::Finished:
@@ -248,12 +245,13 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromVsWhere(const QSt
         qWarning().noquote() << QDir::toNativeSeparators(vswhere) << "could not be started.";
         return installations;
     case Utils::SynchronousProcessResponse::FinishedError:
-        qWarning().noquote().nospace() << QDir::toNativeSeparators(vswhere) << " finished with exit "
-                                          "code " << response.exitCode << ".";
+        qWarning().noquote().nospace() << QDir::toNativeSeparators(vswhere)
+                                       << " finished with exit code "
+                                       << response.exitCode << ".";
         return installations;
     case Utils::SynchronousProcessResponse::TerminatedAbnormally:
-        qWarning().noquote().nospace() << QDir::toNativeSeparators(vswhere) << " crashed. Exit code: "
-                                       << response.exitCode;
+        qWarning().noquote().nospace()
+            << QDir::toNativeSeparators(vswhere) << " crashed. Exit code: " << response.exitCode;
         return installations;
     case Utils::SynchronousProcessResponse::Hang:
         qWarning().noquote() << QDir::toNativeSeparators(vswhere) << "did not finish in" << timeoutS
@@ -296,7 +294,7 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromVsWhere(const QSt
         }
         const QString installationPath = value.toString();
         Utils::optional<VisualStudioInstallation> installation
-                = installationFromPathAndVersion(installationPath, version);
+            = installationFromPathAndVersion(installationPath, version);
 
         if (installation)
             installations.append(*installation);
@@ -308,9 +306,11 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromRegistry()
 {
     QVector<VisualStudioInstallation> result;
 #ifdef Q_OS_WIN64
-    const QString keyRoot = QStringLiteral("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\");
+    const QString keyRoot = QStringLiteral(
+        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\");
 #else
-    const QString keyRoot = QStringLiteral("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\");
+    const QString keyRoot = QStringLiteral(
+        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\");
 #endif
     QSettings vsRegistry(keyRoot + QStringLiteral("VS7"), QSettings::NativeFormat);
     QScopedPointer<QSettings> vcRegistry;
@@ -320,7 +320,7 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromRegistry()
             const QString installationPath = fixRegistryPath(vsRegistry.value(vsName).toString());
 
             Utils::optional<VisualStudioInstallation> installation
-                    = installationFromPathAndVersion(installationPath, version);
+                = installationFromPathAndVersion(installationPath, version);
             if (installation)
                 result.append(*installation);
         }
@@ -337,10 +337,10 @@ static QVector<VisualStudioInstallation> detectVisualStudioFromRegistry()
 static QVector<VisualStudioInstallation> detectVisualStudio()
 {
     const QString vswhere = windowsProgramFilesDir()
-                                + "/Microsoft Visual Studio/Installer/vswhere.exe";
+                            + "/Microsoft Visual Studio/Installer/vswhere.exe";
     if (QFileInfo::exists(vswhere)) {
-        const QVector<VisualStudioInstallation> installations
-                = detectVisualStudioFromVsWhere(vswhere);
+        const QVector<VisualStudioInstallation> installations = detectVisualStudioFromVsWhere(
+            vswhere);
         if (!installations.isEmpty())
             return installations;
     }
@@ -348,14 +348,15 @@ static QVector<VisualStudioInstallation> detectVisualStudio()
     return detectVisualStudioFromRegistry();
 }
 
-static Abi findAbiOfMsvc(MsvcToolChain::Type type, MsvcToolChain::Platform platform, const QString &version)
+static Abi findAbiOfMsvc(MsvcToolChain::Type type,
+                         MsvcToolChain::Platform platform,
+                         const QString &version)
 {
     Abi::Architecture arch = Abi::X86Architecture;
     Abi::OSFlavor flavor = Abi::UnknownFlavor;
     int wordWidth = 64;
 
-    switch (platform)
-    {
+    switch (platform) {
     case MsvcToolChain::x86:
     case MsvcToolChain::amd64_x86:
         wordWidth = 32;
@@ -399,7 +400,8 @@ static Abi findAbiOfMsvc(MsvcToolChain::Type type, MsvcToolChain::Platform platf
     const Abi result = Abi(arch, Abi::WindowsOS, flavor, Abi::PEFormat, wordWidth);
     if (!result.isValid())
         qWarning("Unable to completely determine the ABI of MSVC version %s (%s).",
-                 qPrintable(version), qPrintable(result.toString()));
+                 qPrintable(version),
+                 qPrintable(result.toString()));
     return result;
 }
 
@@ -427,75 +429,73 @@ static QByteArray msvcCompilationDefine(const char *def)
 
 static QByteArray msvcCompilationFile()
 {
-    static const char* macros[] = {
-        "_ATL_VER",
-        "__ATOM__",
-        "__AVX__",
-        "__AVX2__",
-        "_CHAR_UNSIGNED",
-        "__CLR_VER",
-        "_CMMN_INTRIN_FUNC",
-        "_CONTROL_FLOW_GUARD",
-        "__cplusplus",
-        "__cplusplus_cli",
-        "__cplusplus_winrt",
-        "_CPPLIB_VER",
-        "_CPPRTTI",
-        "_CPPUNWIND",
-        "_DEBUG",
-        "_DLL",
-        "_INTEGRAL_MAX_BITS",
-        "__INTELLISENSE__",
-        "_ISO_VOLATILE",
-        "_KERNEL_MODE",
-        "_M_AAMD64",
-        "_M_ALPHA",
-        "_M_AMD64",
-        "_MANAGED",
-        "_M_ARM",
-        "_M_ARM64",
-        "_M_ARM_ARMV7VE",
-        "_M_ARM_FP",
-        "_M_ARM_NT",
-        "_M_ARMT",
-        "_M_CEE",
-        "_M_CEE_PURE",
-        "_M_CEE_SAFE",
-        "_MFC_VER",
-        "_M_FP_EXCEPT",
-        "_M_FP_FAST",
-        "_M_FP_PRECISE",
-        "_M_FP_STRICT",
-        "_M_IA64",
-        "_M_IX86",
-        "_M_IX86_FP",
-        "_M_MPPC",
-        "_M_MRX000",
-        "_M_PPC",
-        "_MSC_BUILD",
-        "_MSC_EXTENSIONS",
-        "_MSC_FULL_VER",
-        "_MSC_VER",
-        "_MSVC_LANG",
-        "__MSVC_RUNTIME_CHECKS",
-        "_MT",
-        "_M_THUMB",
-        "_M_X64",
-        "_NATIVE_WCHAR_T_DEFINED",
-        "_OPENMP",
-        "_PREFAST_",
-        "__STDC__",
-        "__STDC_HOSTED__",
-        "__STDCPP_THREADS__",
-        "_VC_NODEFAULTLIB",
-        "_WCHAR_T_DEFINED",
-        "_WIN32",
-        "_WIN32_WCE",
-        "_WIN64",
-        "_WINRT_DLL",
-        "_Wp64",
-        nullptr
-    };
+    static const char *macros[] = {"_ATL_VER",
+                                   "__ATOM__",
+                                   "__AVX__",
+                                   "__AVX2__",
+                                   "_CHAR_UNSIGNED",
+                                   "__CLR_VER",
+                                   "_CMMN_INTRIN_FUNC",
+                                   "_CONTROL_FLOW_GUARD",
+                                   "__cplusplus",
+                                   "__cplusplus_cli",
+                                   "__cplusplus_winrt",
+                                   "_CPPLIB_VER",
+                                   "_CPPRTTI",
+                                   "_CPPUNWIND",
+                                   "_DEBUG",
+                                   "_DLL",
+                                   "_INTEGRAL_MAX_BITS",
+                                   "__INTELLISENSE__",
+                                   "_ISO_VOLATILE",
+                                   "_KERNEL_MODE",
+                                   "_M_AAMD64",
+                                   "_M_ALPHA",
+                                   "_M_AMD64",
+                                   "_MANAGED",
+                                   "_M_ARM",
+                                   "_M_ARM64",
+                                   "_M_ARM_ARMV7VE",
+                                   "_M_ARM_FP",
+                                   "_M_ARM_NT",
+                                   "_M_ARMT",
+                                   "_M_CEE",
+                                   "_M_CEE_PURE",
+                                   "_M_CEE_SAFE",
+                                   "_MFC_VER",
+                                   "_M_FP_EXCEPT",
+                                   "_M_FP_FAST",
+                                   "_M_FP_PRECISE",
+                                   "_M_FP_STRICT",
+                                   "_M_IA64",
+                                   "_M_IX86",
+                                   "_M_IX86_FP",
+                                   "_M_MPPC",
+                                   "_M_MRX000",
+                                   "_M_PPC",
+                                   "_MSC_BUILD",
+                                   "_MSC_EXTENSIONS",
+                                   "_MSC_FULL_VER",
+                                   "_MSC_VER",
+                                   "_MSVC_LANG",
+                                   "__MSVC_RUNTIME_CHECKS",
+                                   "_MT",
+                                   "_M_THUMB",
+                                   "_M_X64",
+                                   "_NATIVE_WCHAR_T_DEFINED",
+                                   "_OPENMP",
+                                   "_PREFAST_",
+                                   "__STDC__",
+                                   "__STDC_HOSTED__",
+                                   "__STDCPP_THREADS__",
+                                   "_VC_NODEFAULTLIB",
+                                   "_WCHAR_T_DEFINED",
+                                   "_WIN32",
+                                   "_WIN32_WCE",
+                                   "_WIN64",
+                                   "_WINRT_DLL",
+                                   "_Wp64",
+                                   nullptr};
     QByteArray file = "#define __PPOUT__(x) V##x=x\n\n";
     for (int i = 0; macros[i] != nullptr; ++i)
         file += msvcCompilationDefine(macros[i]);
@@ -571,13 +571,15 @@ Macros MsvcToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
             const QString define = arg.mid(2);
             predefinedMacros.append(Macro::fromKeyValue(define));
         } else if (arg.startsWith(QLatin1String("/U"))) {
-            predefinedMacros.append({arg.mid(2).toLocal8Bit(), ProjectExplorer::MacroType::Undefine});
+            predefinedMacros.append(
+                {arg.mid(2).toLocal8Bit(), ProjectExplorer::MacroType::Undefine});
         } else {
             toProcess.append(arg);
         }
     }
 
-    Utils::TempFileSaver saver(Utils::TemporaryDirectory::masterDirectoryPath() + "/envtestXXXXXX.cpp");
+    Utils::TempFileSaver saver(Utils::TemporaryDirectory::masterDirectoryPath()
+                               + "/envtestXXXXXX.cpp");
     saver.write(msvcCompilationFile());
     if (!saver.finalize()) {
         qWarning("%s: %s", Q_FUNC_INFO, qPrintable(saver.errorString()));
@@ -597,8 +599,7 @@ Macros MsvcToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
         arguments << QLatin1String("/TC");
     arguments << toProcess << QLatin1String("/EP") << QDir::toNativeSeparators(saver.fileName());
     Utils::SynchronousProcessResponse response = cpp.runBlocking(binary.toString(), arguments);
-    if (response.result != Utils::SynchronousProcessResponse::Finished ||
-            response.exitCode != 0)
+    if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0)
         return predefinedMacros;
 
     const QStringList output = Utils::filtered(response.stdOut().split('\n'),
@@ -664,7 +665,7 @@ LanguageVersion MsvcToolChain::msvcLanguageVersion(const QStringList & /*cxxflag
 static QString winExpandDelayedEnvReferences(QString in, const Utils::Environment &env)
 {
     const QChar exclamationMark = QLatin1Char('!');
-    for (int pos = 0; pos < in.size(); ) {
+    for (int pos = 0; pos < in.size();) {
         // Replace "!REF!" by its value in process environment
         pos = in.indexOf(exclamationMark, pos);
         if (pos == -1)
@@ -681,17 +682,19 @@ static QString winExpandDelayedEnvReferences(QString in, const Utils::Environmen
 }
 
 void MsvcToolChain::environmentModifications(
-        QFutureInterface<MsvcToolChain::GenerateEnvResult> &future,
-        QString vcvarsBat, QString varsBatArg)
+    QFutureInterface<MsvcToolChain::GenerateEnvResult> &future,
+    QString vcvarsBat,
+    QString varsBatArg)
 {
     const Utils::Environment inEnv = Utils::Environment::systemEnvironment();
     Utils::Environment outEnv;
     QMap<QString, QString> envPairs;
     QList<Utils::EnvironmentItem> diff;
-    Utils::optional<QString> error = generateEnvironmentSettings(inEnv, vcvarsBat,
-                                                                 varsBatArg, envPairs);
+    Utils::optional<QString> error = generateEnvironmentSettings(inEnv,
+                                                                 vcvarsBat,
+                                                                 varsBatArg,
+                                                                 envPairs);
     if (!error) {
-
         // Now loop through and process them
         for (auto envIter = envPairs.cbegin(), end = envPairs.cend(); envIter != end; ++envIter) {
             const QString expandedValue = winExpandDelayedEnvReferences(envIter.value(), inEnv);
@@ -744,7 +747,7 @@ void MsvcToolChain::updateEnvironmentModifications(QList<Utils::EnvironmentItem>
     }
 }
 
-Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environment& env) const
+Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environment &env) const
 {
     Utils::Environment resultEnv = env;
     if (m_environmentModifications.isEmpty()) {
@@ -769,11 +772,14 @@ Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environmen
 // MsvcToolChain
 // --------------------------------------------------------------------------
 
-MsvcToolChain::MsvcToolChain(const QString &name, const Abi &abi,
-                             const QString &varsBat, const QString &varsBatArg, Core::Id l,
-                             Detection d) :
-    MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, l, d)
-{ }
+MsvcToolChain::MsvcToolChain(const QString &name,
+                             const Abi &abi,
+                             const QString &varsBat,
+                             const QString &varsBatArg,
+                             Core::Id l,
+                             Detection d)
+    : MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, l, d)
+{}
 
 MsvcToolChain::MsvcToolChain(const MsvcToolChain &other)
     : ToolChain(other)
@@ -804,8 +810,12 @@ MsvcToolChain::MsvcToolChain(const MsvcToolChain &other)
     setDisplayName(other.displayName());
 }
 
-MsvcToolChain::MsvcToolChain(Core::Id typeId, const QString &name, const Abi &abi,
-                             const QString &varsBat, const QString &varsBatArg, Core::Id l,
+MsvcToolChain::MsvcToolChain(Core::Id typeId,
+                             const QString &name,
+                             const Abi &abi,
+                             const QString &varsBat,
+                             const QString &varsBatArg,
+                             Core::Id l,
                              Detection d)
     : ToolChain(typeId, d)
     , m_predefinedMacrosCache(std::make_shared<Cache<MacroInspectionReport, 64>>())
@@ -818,7 +828,8 @@ MsvcToolChain::MsvcToolChain(Core::Id typeId, const QString &name, const Abi &ab
     setLanguage(l);
     initEnvModWatcher(Utils::runAsync(envModThreadPool(),
                                       &MsvcToolChain::environmentModifications,
-                                      varsBat, varsBatArg));
+                                      varsBat,
+                                      varsBatArg));
 
     Q_ASSERT(!name.isEmpty());
 
@@ -829,7 +840,7 @@ MsvcToolChain::MsvcToolChain(Core::Id typeId)
     : ToolChain(typeId, ManualDetection)
     , m_predefinedMacrosCache(std::make_shared<Cache<MacroInspectionReport, 64>>())
     , m_lastEnvironment(Utils::Environment::systemEnvironment())
-{ }
+{}
 
 void MsvcToolChain::inferWarningsForLevel(int warningLevel, WarningFlags &flags)
 {
@@ -837,12 +848,14 @@ void MsvcToolChain::inferWarningsForLevel(int warningLevel, WarningFlags &flags)
     flags = flags & WarningFlags::AsErrors;
 
     if (warningLevel >= 1)
-        flags |= WarningFlags(WarningFlags::Default | WarningFlags::IgnoredQualfiers | WarningFlags::HiddenLocals  | WarningFlags::UnknownPragma);
+        flags |= WarningFlags(WarningFlags::Default | WarningFlags::IgnoredQualfiers
+                              | WarningFlags::HiddenLocals | WarningFlags::UnknownPragma);
     if (warningLevel >= 2)
         flags |= WarningFlags::All;
     if (warningLevel >= 3) {
-        flags |= WarningFlags(WarningFlags::Extra | WarningFlags::NonVirtualDestructor | WarningFlags::SignedComparison
-                              | WarningFlags::UnusedLocals | WarningFlags::Deprecated);
+        flags |= WarningFlags(WarningFlags::Extra | WarningFlags::NonVirtualDestructor
+                              | WarningFlags::SignedComparison | WarningFlags::UnusedLocals
+                              | WarningFlags::Deprecated);
     }
     if (warningLevel >= 4)
         flags |= WarningFlags::UnusedParams;
@@ -853,8 +866,9 @@ void MsvcToolChain::toolChainUpdated()
     m_predefinedMacrosCache->invalidate();
 }
 
-MsvcToolChain::MsvcToolChain() : MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID)
-{ }
+MsvcToolChain::MsvcToolChain()
+    : MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID)
+{}
 
 MsvcToolChain::~MsvcToolChain()
 {
@@ -876,9 +890,8 @@ bool MsvcToolChain::isValid() const
 
 QString MsvcToolChain::originalTargetTriple() const
 {
-    return m_abi.wordWidth() == 64
-               ? QLatin1String("x86_64-pc-windows-msvc")
-            : QLatin1String("i686-pc-windows-msvc");
+    return m_abi.wordWidth() == 64 ? QLatin1String("x86_64-pc-windows-msvc")
+                                   : QLatin1String("i686-pc-windows-msvc");
 }
 
 QString MsvcToolChain::typeDisplayName() const
@@ -902,25 +915,25 @@ Utils::FileNameList MsvcToolChain::suggestedMkspecList() const
         break;
     case Abi::WindowsMsvc2012Flavor:
         result << Utils::FileName::fromLatin1("win32-msvc2012")
-            << Utils::FileName::fromLatin1("win32-msvc2010");
+               << Utils::FileName::fromLatin1("win32-msvc2010");
         break;
     case Abi::WindowsMsvc2013Flavor:
         result << Utils::FileName::fromLatin1("win32-msvc2013")
-            << Utils::FileName::fromLatin1("winphone-arm-msvc2013")
-            << Utils::FileName::fromLatin1("winphone-x86-msvc2013")
-            << Utils::FileName::fromLatin1("winrt-arm-msvc2013")
-            << Utils::FileName::fromLatin1("winrt-x86-msvc2013")
-            << Utils::FileName::fromLatin1("winrt-x64-msvc2013")
-            << Utils::FileName::fromLatin1("win32-msvc2012")
-            << Utils::FileName::fromLatin1("win32-msvc2010");
+               << Utils::FileName::fromLatin1("winphone-arm-msvc2013")
+               << Utils::FileName::fromLatin1("winphone-x86-msvc2013")
+               << Utils::FileName::fromLatin1("winrt-arm-msvc2013")
+               << Utils::FileName::fromLatin1("winrt-x86-msvc2013")
+               << Utils::FileName::fromLatin1("winrt-x64-msvc2013")
+               << Utils::FileName::fromLatin1("win32-msvc2012")
+               << Utils::FileName::fromLatin1("win32-msvc2010");
         break;
     case Abi::WindowsMsvc2015Flavor:
         result << Utils::FileName::fromLatin1("win32-msvc2015")
-            << Utils::FileName::fromLatin1("winphone-arm-msvc2015")
-            << Utils::FileName::fromLatin1("winphone-x86-msvc2015")
-            << Utils::FileName::fromLatin1("winrt-arm-msvc2015")
-            << Utils::FileName::fromLatin1("winrt-x86-msvc2015")
-            << Utils::FileName::fromLatin1("winrt-x64-msvc2015");
+               << Utils::FileName::fromLatin1("winphone-arm-msvc2015")
+               << Utils::FileName::fromLatin1("winphone-x86-msvc2015")
+               << Utils::FileName::fromLatin1("winrt-arm-msvc2015")
+               << Utils::FileName::fromLatin1("winrt-x86-msvc2015")
+               << Utils::FileName::fromLatin1("winrt-x64-msvc2015");
         break;
     case Abi::WindowsMsvc2017Flavor:
         result << Utils::FileName::fromLatin1("win32-msvc2017")
@@ -957,16 +970,16 @@ bool MsvcToolChain::fromMap(const QVariantMap &data)
     const QString abiString = data.value(QLatin1String(supportedAbiKeyC)).toString();
     m_abi = Abi::fromString(abiString);
     m_environmentModifications = Utils::EnvironmentItem::itemsFromVariantList(
-                data.value(QLatin1String(environModsKeyC)).toList());
+        data.value(QLatin1String(environModsKeyC)).toList());
 
     initEnvModWatcher(Utils::runAsync(envModThreadPool(),
                                       &MsvcToolChain::environmentModifications,
-                                      m_vcvarsBat, m_varsBatArg));
+                                      m_vcvarsBat,
+                                      m_varsBatArg));
 
     return !m_vcvarsBat.isEmpty() && m_abi.isValid();
 }
 
-
 std::unique_ptr<ToolChainConfigWidget> MsvcToolChain::createConfigurationWidget()
 {
     return std::make_unique<MsvcToolChainConfigWidget>(this);
@@ -1046,16 +1059,18 @@ WarningFlags MsvcToolChain::warningFlags(const QStringList &cflags) const
         if (!flag.isEmpty() && flag[0] == QLatin1Char('-'))
             flag[0] = QLatin1Char('/');
 
-        if (flag == QLatin1String("/WX"))
+        if (flag == QLatin1String("/WX")) {
             flags |= WarningFlags::AsErrors;
-        else if (flag == QLatin1String("/W0") || flag == QLatin1String("/w"))
+        } else if (flag == QLatin1String("/W0") || flag == QLatin1String("/w")) {
             inferWarningsForLevel(0, flags);
-        else if (flag == QLatin1String("/W1"))
+        } else if (flag == QLatin1String("/W1")) {
             inferWarningsForLevel(1, flags);
-        else if (flag == QLatin1String("/W2"))
+        } else if (flag == QLatin1String("/W2")) {
             inferWarningsForLevel(2, flags);
-        else if (flag == QLatin1String("/W3") || flag == QLatin1String("/W4") || flag == QLatin1String("/Wall"))
+        } else if (flag == QLatin1String("/W3") || flag == QLatin1String("/W4")
+                   || flag == QLatin1String("/Wall")) {
             inferWarningsForLevel(3, flags);
+        }
 
         WarningFlagAdder add(flag, flags);
         if (add.triggered())
@@ -1092,14 +1107,17 @@ ToolChain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunne
     return [this, env](const QStringList &, const QString &) {
         QMutexLocker locker(m_headerPathsMutex);
         if (m_headerPaths.isEmpty()) {
-            foreach (const QString &path, env.value(QLatin1String("INCLUDE")).split(QLatin1Char(';')))
+            foreach (const QString &path,
+                     env.value(QLatin1String("INCLUDE")).split(QLatin1Char(';'))) {
                 m_headerPaths.append({path, HeaderPathType::BuiltIn});
+            }
         }
         return m_headerPaths;
     };
 }
 
-HeaderPaths MsvcToolChain::builtInHeaderPaths(const QStringList &cxxflags, const Utils::FileName &sysRoot) const
+HeaderPaths MsvcToolChain::builtInHeaderPaths(const QStringList &cxxflags,
+                                              const Utils::FileName &sysRoot) const
 {
     return createBuiltInHeaderPathsRunner()(cxxflags, sysRoot.toString());
 }
@@ -1138,7 +1156,9 @@ QString MsvcToolChain::makeCommand(const Utils::Environment &environment) const
 
     QString command;
     if (useJom) {
-        tmp = environment.searchInPath(jom, {Utils::FileName::fromString(QCoreApplication::applicationDirPath())});
+        tmp = environment.searchInPath(jom,
+                                       {Utils::FileName::fromString(
+                                           QCoreApplication::applicationDirPath())});
         if (!tmp.isEmpty())
             command = tmp.toString();
     }
@@ -1163,15 +1183,16 @@ Utils::FileName MsvcToolChain::compilerCommand() const
     Utils::Environment env = Utils::Environment::systemEnvironment();
     addToEnvironment(env);
 
-    Utils::FileName clexe = env.searchInPath(QLatin1String("cl.exe"), {}, [](const Utils::FileName &name) {
-        QDir dir(QDir::cleanPath(name.toFileInfo().absolutePath() + QStringLiteral("/..")));
-        do {
-            if (QFile::exists(dir.absoluteFilePath(QStringLiteral("vcvarsall.bat")))
-                || QFile::exists(dir.absolutePath() + "/Auxiliary/Build/vcvarsall.bat"))
-                return true;
-        } while (dir.cdUp() && !dir.isRoot());
-        return false;
-    });
+    Utils::FileName clexe
+        = env.searchInPath(QLatin1String("cl.exe"), {}, [](const Utils::FileName &name) {
+              QDir dir(QDir::cleanPath(name.toFileInfo().absolutePath() + QStringLiteral("/..")));
+              do {
+                  if (QFile::exists(dir.absoluteFilePath(QStringLiteral("vcvarsall.bat")))
+                      || QFile::exists(dir.absolutePath() + "/Auxiliary/Build/vcvarsall.bat"))
+                      return true;
+              } while (dir.cdUp() && !dir.isRoot());
+              return false;
+          });
     return clexe;
 }
 
@@ -1186,10 +1207,10 @@ IOutputParser *MsvcToolChain::outputParser() const
 // call setFromMsvcToolChain().
 // --------------------------------------------------------------------------
 
-MsvcBasedToolChainConfigWidget::MsvcBasedToolChainConfigWidget(ToolChain *tc) :
-    ToolChainConfigWidget(tc),
-    m_nameDisplayLabel(new QLabel(this)),
-    m_varsBatDisplayLabel(new QLabel(this))
+MsvcBasedToolChainConfigWidget::MsvcBasedToolChainConfigWidget(ToolChain *tc)
+    : ToolChainConfigWidget(tc)
+    , m_nameDisplayLabel(new QLabel(this))
+    , m_varsBatDisplayLabel(new QLabel(this))
 {
     m_nameDisplayLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     m_mainLayout->addRow(m_nameDisplayLabel);
@@ -1200,7 +1221,7 @@ MsvcBasedToolChainConfigWidget::MsvcBasedToolChainConfigWidget(ToolChain *tc) :
 void MsvcBasedToolChainConfigWidget::setFromMsvcToolChain()
 {
     const auto *tc = static_cast<const MsvcToolChain *>(toolChain());
-    QTC_ASSERT(tc, return);
+    QTC_ASSERT(tc, return );
     m_nameDisplayLabel->setText(tc->displayName());
     QString varsBatDisplay = QDir::toNativeSeparators(tc->varsBat());
     if (!tc->varsBatArg().isEmpty()) {
@@ -1214,8 +1235,8 @@ void MsvcBasedToolChainConfigWidget::setFromMsvcToolChain()
 // MsvcToolChainConfigWidget
 // --------------------------------------------------------------------------
 
-MsvcToolChainConfigWidget::MsvcToolChainConfigWidget(ToolChain *tc) :
-    MsvcBasedToolChainConfigWidget(tc)
+MsvcToolChainConfigWidget::MsvcToolChainConfigWidget(ToolChain *tc)
+    : MsvcBasedToolChainConfigWidget(tc)
 {
     addErrorLabel();
     setFromMsvcToolChain();
@@ -1244,8 +1265,10 @@ ClangClToolChainConfigWidget::ClangClToolChainConfigWidget(ToolChain *tc)
     setFromClangClToolChain();
 
     if (m_compilerCommand) {
-        connect(m_compilerCommand, &Utils::PathChooser::rawPathChanged,
-                this, &ClangClToolChainConfigWidget::dirty);
+        connect(m_compilerCommand,
+                &Utils::PathChooser::rawPathChanged,
+                this,
+                &ClangClToolChainConfigWidget::dirty);
     }
 }
 
@@ -1262,28 +1285,28 @@ void ClangClToolChainConfigWidget::setFromClangClToolChain()
 static const MsvcToolChain *findMsvcToolChain(unsigned char wordWidth, Abi::OSFlavor flavor)
 {
     return Utils::findOrDefault(g_availableMsvcToolchains,
-                                [wordWidth, flavor] (const MsvcToolChain *tc)
-    { const Abi abi = tc->targetAbi();
-        return abi.osFlavor() == flavor
-                && wordWidth == abi.wordWidth();} );
+                                [wordWidth, flavor](const MsvcToolChain *tc) {
+                                    const Abi abi = tc->targetAbi();
+                                    return abi.osFlavor() == flavor && wordWidth == abi.wordWidth();
+                                });
 }
 
-static QVersionNumber clangClVersion(const QString& clangClPath)
+static QVersionNumber clangClVersion(const QString &clangClPath)
 {
     Utils::SynchronousProcess clangClProcess;
-    const Utils::SynchronousProcessResponse response = clangClProcess.runBlocking(
-                clangClPath, {QStringLiteral("--version")});
+    const Utils::SynchronousProcessResponse response
+        = clangClProcess.runBlocking(clangClPath, {QStringLiteral("--version")});
     if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0)
         return {};
     const QRegularExpressionMatch match = QRegularExpression(
-                QStringLiteral("clang version (\\d+(\\.\\d+)+)")).match(response.stdOut());
+                                              QStringLiteral("clang version (\\d+(\\.\\d+)+)"))
+                                              .match(response.stdOut());
     if (!match.hasMatch())
         return {};
     return QVersionNumber::fromString(match.captured(1));
 }
 
-static const MsvcToolChain *selectMsvcToolChain(const QString &clangClPath,
-                                                unsigned char wordWidth)
+static const MsvcToolChain *selectMsvcToolChain(const QString &clangClPath, unsigned char wordWidth)
 {
     const MsvcToolChain *toolChain = nullptr;
     const QVersionNumber version = clangClVersion(clangClPath);
@@ -1297,8 +1320,9 @@ static const MsvcToolChain *selectMsvcToolChain(const QString &clangClPath,
     return toolChain;
 }
 
-static QList<ToolChain *> detectClangClToolChainInPath(
-        const QString &clangClPath, const QList<ToolChain *> &alreadyKnown, bool isDefault = false)
+static QList<ToolChain *> detectClangClToolChainInPath(const QString &clangClPath,
+                                                       const QList<ToolChain *> &alreadyKnown,
+                                                       bool isDefault = false)
 {
     QList<ToolChain *> res;
     const unsigned char wordWidth = Utils::is64BitWindowsBinary(clangClPath) ? 64 : 32;
@@ -1313,22 +1337,21 @@ static QList<ToolChain *> detectClangClToolChainInPath(
     Utils::Environment systemEnvironment = Utils::Environment::systemEnvironment();
     const Abi targetAbi = toolChain->targetAbi();
     const QString name = QString("%1LLVM %2 bit based on %3")
-              .arg(QLatin1String(isDefault ? "Default " : ""))
-              .arg(wordWidth)
-              .arg(Abi::toString(targetAbi.osFlavor()).toUpper());
-    for (auto language: {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
+                             .arg(QLatin1String(isDefault ? "Default " : ""))
+                             .arg(wordWidth)
+                             .arg(Abi::toString(targetAbi.osFlavor()).toUpper());
+    for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
         ClangClToolChain *tc = static_cast<ClangClToolChain *>(
-                    Utils::findOrDefault(
-                        alreadyKnown,
-                        [&targetAbi, &language, &clangClPath, &systemEnvironment](ToolChain *tc) -> bool {
-            if (tc->typeId() != Constants::CLANG_CL_TOOLCHAIN_TYPEID)
-                return false;
-            if (tc->targetAbi() != targetAbi)
-                return false;
-            if (tc->language() != language)
-                return false;
-            return systemEnvironment.isSameExecutable(tc->compilerCommand().toString(), clangClPath);
-        }));
+            Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
+                if (tc->typeId() != Constants::CLANG_CL_TOOLCHAIN_TYPEID)
+                    return false;
+                if (tc->targetAbi() != targetAbi)
+                    return false;
+                if (tc->language() != language)
+                    return false;
+                return systemEnvironment.isSameExecutable(tc->compilerCommand().toString(),
+                                                          clangClPath);
+            }));
         if (!tc) {
             tc = new ClangClToolChain(name, clangClPath, language, ToolChain::AutoDetection);
             tc->resetMsvcToolChain(toolChain);
@@ -1346,7 +1369,7 @@ static QString compilerFromPath(const QString &path)
 void ClangClToolChainConfigWidget::applyImpl()
 {
     Utils::FileName clangClPath = m_compilerCommand->fileName();
-        auto clangClToolChain = static_cast<ClangClToolChain *>(toolChain());
+    auto clangClToolChain = static_cast<ClangClToolChain *>(toolChain());
     clangClToolChain->setClangPath(clangClPath.toString());
 
     if (clangClPath.fileName() != "clang-cl.exe") {
@@ -1382,21 +1405,22 @@ void ClangClToolChainConfigWidget::discardImpl()
 // clang-cl.exe as a [to some extent] compatible drop-in replacement for cl.
 // --------------------------------------------------------------------------
 
-ClangClToolChain::ClangClToolChain(const QString &name, const QString &clangPath,
+ClangClToolChain::ClangClToolChain(const QString &name,
+                                   const QString &clangPath,
                                    Core::Id language,
                                    Detection d)
     : MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID, name, Abi(), "", "", language, d)
     , m_clangPath(clangPath)
-{
-}
+{}
 
-ClangClToolChain::ClangClToolChain() : MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID)
-{ }
+ClangClToolChain::ClangClToolChain()
+    : MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID)
+{}
 
 bool ClangClToolChain::isValid() const
 {
     return MsvcToolChain::isValid() && compilerCommand().exists()
-            && compilerCommand().fileName() == "clang-cl.exe";
+           && compilerCommand().fileName() == "clang-cl.exe";
 }
 
 void ClangClToolChain::addToEnvironment(Utils::Environment &env) const
@@ -1433,7 +1457,10 @@ ToolChain *ClangClToolChain::clone() const
     return new ClangClToolChain(*this);
 }
 
-static inline QString llvmDirKey() { return QStringLiteral("ProjectExplorer.ClangClToolChain.LlvmDir"); }
+static inline QString llvmDirKey()
+{
+    return QStringLiteral("ProjectExplorer.ClangClToolChain.LlvmDir");
+}
 
 QVariantMap ClangClToolChain::toMap() const
 {
@@ -1473,12 +1500,13 @@ void ClangClToolChain::resetMsvcToolChain(const MsvcToolChain *base)
 
     initEnvModWatcher(Utils::runAsync(envModThreadPool(),
                                       &ClangClToolChain::environmentModifications,
-                                      m_vcvarsBat, base->varsBatArg()));
+                                      m_vcvarsBat,
+                                      base->varsBatArg()));
 }
 
-bool ClangClToolChain::operator ==(const ToolChain &other) const
+bool ClangClToolChain::operator==(const ToolChain &other) const
 {
-    if (!MsvcToolChain::operator ==(other))
+    if (!MsvcToolChain::operator==(other))
         return false;
 
     const auto *clangClTc = static_cast<const ClangClToolChain *>(&other);
@@ -1500,8 +1528,7 @@ Macros ClangClToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
     arguments.append("-");
     Utils::SynchronousProcessResponse response = cpp.runBlocking(compilerCommand().toString(),
                                                                  arguments);
-    if (response.result != Utils::SynchronousProcessResponse::Finished ||
-            response.exitCode != 0) {
+    if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0) {
         // Show the warning but still parse the output.
         QTC_CHECK(false && "clang-cl exited with non-zero code.");
     }
@@ -1532,7 +1559,8 @@ QSet<Core::Id> MsvcToolChainFactory::supportedLanguages() const
     return {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID};
 }
 
-QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath, MsvcToolChain::Platform platform,
+QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath,
+                                           MsvcToolChain::Platform platform,
                                            const QVersionNumber &v)
 {
     QString result;
@@ -1547,17 +1575,16 @@ QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath, MsvcToolChai
     return result;
 }
 
-static QList<ToolChain *> findOrCreateToolChain(
-        const QList<ToolChain *> &alreadyKnown,
-        const QString &name, const Abi &abi,
-        const QString &varsBat, const QString &varsBatArg,
-        ToolChain::Detection d = ToolChain::ManualDetection)
+static QList<ToolChain *> findOrCreateToolChain(const QList<ToolChain *> &alreadyKnown,
+                                                const QString &name,
+                                                const Abi &abi,
+                                                const QString &varsBat,
+                                                const QString &varsBatArg,
+                                                ToolChain::Detection d = ToolChain::ManualDetection)
 {
     QList<ToolChain *> res;
-    for (auto language: {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
-        ToolChain *tc = Utils::findOrDefault(
-                    alreadyKnown,
-                    [&varsBat, &varsBatArg, &abi, &language](ToolChain *tc) -> bool {
+    for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
+        ToolChain *tc = Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
             if (tc->typeId() != Constants::MSVC_TOOLCHAIN_TYPEID)
                 return false;
             if (tc->targetAbi() != abi)
@@ -1565,8 +1592,7 @@ static QList<ToolChain *> findOrCreateToolChain(
             if (tc->language() != language)
                 return false;
             auto mtc = static_cast<MsvcToolChain *>(tc);
-            return mtc->varsBat() == varsBat
-                    && mtc->varsBatArg() == varsBatArg;
+            return mtc->varsBat() == varsBat && mtc->varsBatArg() == varsBatArg;
         });
         if (!tc)
             tc = new MsvcToolChain(name, abi, varsBat, varsBatArg, language, d);
@@ -1578,7 +1604,8 @@ static QList<ToolChain *> findOrCreateToolChain(
 // Detect build tools introduced with MSVC2015
 static void detectCppBuildTools2015(QList<ToolChain *> *list)
 {
-    struct Entry {
+    struct Entry
+    {
         const char *postFix;
         const char *varsBatArg;
         Abi::Architecture architecture;
@@ -1586,25 +1613,29 @@ static void detectCppBuildTools2015(QList<ToolChain *> *list)
         unsigned char wordSize;
     };
 
-    const Entry entries[] = {
-        {" (x86)", "x86", Abi::X86Architecture, Abi::PEFormat, 32},
-        {" (x64)", "amd64", Abi::X86Architecture, Abi::PEFormat, 64},
-        {" (x86_arm)", "x86_arm", Abi::ArmArchitecture, Abi::PEFormat, 32},
-        {" (x64_arm)", "amd64_arm", Abi::ArmArchitecture, Abi::PEFormat, 64}
-    };
+    const Entry entries[] = {{" (x86)", "x86", Abi::X86Architecture, Abi::PEFormat, 32},
+                             {" (x64)", "amd64", Abi::X86Architecture, Abi::PEFormat, 64},
+                             {" (x86_arm)", "x86_arm", Abi::ArmArchitecture, Abi::PEFormat, 32},
+                             {" (x64_arm)", "amd64_arm", Abi::ArmArchitecture, Abi::PEFormat, 64}};
 
     const QString name = QStringLiteral("Microsoft Visual C++ Build Tools");
-    const QString vcVarsBat = windowsProgramFilesDir()
-            + QLatin1Char('/') + name + QStringLiteral("/vcbuildtools.bat");
+    const QString vcVarsBat = windowsProgramFilesDir() + QLatin1Char('/') + name
+                              + QStringLiteral("/vcbuildtools.bat");
     if (!QFileInfo(vcVarsBat).isFile())
         return;
     for (const Entry &e : entries) {
-        const Abi abi(e.architecture, Abi::WindowsOS, Abi::WindowsMsvc2015Flavor,
-                      e.format, e.wordSize);
-        for (auto language: {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
-            list->append(new MsvcToolChain(name + QLatin1String(e.postFix), abi,
-                                           vcVarsBat, QLatin1String(e.varsBatArg),
-                                           language, ToolChain::AutoDetection));
+        const Abi abi(e.architecture,
+                      Abi::WindowsOS,
+                      Abi::WindowsMsvc2015Flavor,
+                      e.format,
+                      e.wordSize);
+        for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
+            list->append(new MsvcToolChain(name + QLatin1String(e.postFix),
+                                           abi,
+                                           vcVarsBat,
+                                           QLatin1String(e.varsBatArg),
+                                           language,
+                                           ToolChain::AutoDetection));
         }
     }
 }
@@ -1614,13 +1645,17 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
     QList<ToolChain *> results;
 
     // 1) Installed SDKs preferred over standalone Visual studio
-    const QSettings sdkRegistry(QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows"),
-                                QSettings::NativeFormat);
-    const QString defaultSdkPath = sdkRegistry.value(QLatin1String("CurrentInstallFolder")).toString();
+    const QSettings
+        sdkRegistry(QLatin1String(
+                        "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows"),
+                    QSettings::NativeFormat);
+    const QString defaultSdkPath = sdkRegistry.value(QLatin1String("CurrentInstallFolder"))
+                                       .toString();
     if (!defaultSdkPath.isEmpty()) {
         foreach (const QString &sdkKey, sdkRegistry.childGroups()) {
             const QString name = sdkRegistry.value(sdkKey + QLatin1String("/ProductName")).toString();
-            const QString folder = sdkRegistry.value(sdkKey + QLatin1String("/InstallationFolder")).toString();
+            const QString folder = sdkRegistry.value(sdkKey + QLatin1String("/InstallationFolder"))
+                                       .toString();
             if (folder.isEmpty())
                 continue;
 
@@ -1632,17 +1667,22 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
                 continue;
 
             QList<ToolChain *> tmp;
-            const QVector<QPair<MsvcToolChain::Platform, QString> > platforms = {
+            const QVector<QPair<MsvcToolChain::Platform, QString>> platforms = {
                 {MsvcToolChain::x86, "x86"},
                 {MsvcToolChain::amd64, "x64"},
                 {MsvcToolChain::ia64, "ia64"},
             };
-            for (auto platform: platforms) {
-                tmp.append(findOrCreateToolChain(
-                               alreadyKnown,
-                               generateDisplayName(name, MsvcToolChain::WindowsSDK, platform.first),
-                               findAbiOfMsvc(MsvcToolChain::WindowsSDK, platform.first, sdkKey),
-                               fi.absoluteFilePath(), "/" + platform.second, ToolChain::AutoDetection));
+            for (auto platform : platforms) {
+                tmp.append(findOrCreateToolChain(alreadyKnown,
+                                                 generateDisplayName(name,
+                                                                     MsvcToolChain::WindowsSDK,
+                                                                     platform.first),
+                                                 findAbiOfMsvc(MsvcToolChain::WindowsSDK,
+                                                               platform.first,
+                                                               sdkKey),
+                                                 fi.absoluteFilePath(),
+                                                 "/" + platform.second,
+                                                 ToolChain::AutoDetection));
             }
             // Make sure the default is front.
             if (folder == defaultSdkPath)
@@ -1657,24 +1697,28 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
     // x86_arm was put before amd64_arm as a workaround for auto detected windows phone
     // toolchains. As soon as windows phone builds support x64 cross builds, this change
     // can be reverted.
-    const MsvcToolChain::Platform platforms[] = {
-        MsvcToolChain::x86, MsvcToolChain::amd64_x86,
-        MsvcToolChain::amd64, MsvcToolChain::x86_amd64,
-        MsvcToolChain::arm, MsvcToolChain::x86_arm, MsvcToolChain::amd64_arm,
-        MsvcToolChain::ia64, MsvcToolChain::x86_ia64
-    };
+    const MsvcToolChain::Platform platforms[] = {MsvcToolChain::x86,
+                                                 MsvcToolChain::amd64_x86,
+                                                 MsvcToolChain::amd64,
+                                                 MsvcToolChain::x86_amd64,
+                                                 MsvcToolChain::arm,
+                                                 MsvcToolChain::x86_arm,
+                                                 MsvcToolChain::amd64_arm,
+                                                 MsvcToolChain::ia64,
+                                                 MsvcToolChain::x86_ia64};
 
     foreach (const VisualStudioInstallation &i, detectVisualStudio()) {
         for (MsvcToolChain::Platform platform : platforms) {
-            const bool toolchainInstalled =
-                QFileInfo(vcVarsBatFor(i.vcVarsPath, platform, i.version)).isFile();
+            const bool toolchainInstalled
+                = QFileInfo(vcVarsBatFor(i.vcVarsPath, platform, i.version)).isFile();
             if (hostSupportsPlatform(platform) && toolchainInstalled) {
-                results.append(findOrCreateToolChain(
-                                   alreadyKnown,
-                                   generateDisplayName(i.vsName, MsvcToolChain::VS, platform),
-                                   findAbiOfMsvc(MsvcToolChain::VS, platform, i.vsName),
-                                   i.vcVarsAll, platformName(platform),
-                                   ToolChain::AutoDetection));
+                results.append(
+                    findOrCreateToolChain(alreadyKnown,
+                                          generateDisplayName(i.vsName, MsvcToolChain::VS, platform),
+                                          findAbiOfMsvc(MsvcToolChain::VS, platform, i.vsName),
+                                          i.vcVarsAll,
+                                          platformName(platform),
+                                          ToolChain::AutoDetection));
             }
         }
     }
@@ -1712,8 +1756,10 @@ QList<ToolChain *> ClangClToolChainFactory::autoDetect(const QList<ToolChain *>
 
     QString qtCreatorsClang = Core::ICore::clangExecutable(CLANG_BINDIR);
     if (!qtCreatorsClang.isEmpty()) {
-        qtCreatorsClang = Utils::FileName::fromString(qtCreatorsClang).parentDir()
-                .appendPath("clang-cl.exe").toString();
+        qtCreatorsClang = Utils::FileName::fromString(qtCreatorsClang)
+                              .parentDir()
+                              .appendPath("clang-cl.exe")
+                              .toString();
         results.append(detectClangClToolChainInPath(qtCreatorsClang, alreadyKnown, true));
         known.append(results);
     }
@@ -1741,14 +1787,13 @@ ToolChain *ClangClToolChainFactory::create(Core::Id l)
     return new ClangClToolChain("clang-cl", "", l, ToolChain::ManualDetection);
 }
 
-bool MsvcToolChain::operator ==(const ToolChain &other) const
+bool MsvcToolChain::operator==(const ToolChain &other) const
 {
-    if (!ToolChain::operator ==(other))
+    if (!ToolChain::operator==(other))
         return false;
 
     const auto *msvcTc = dynamic_cast<const MsvcToolChain *>(&other);
-    return targetAbi() == msvcTc->targetAbi()
-           && m_vcvarsBat == msvcTc->m_vcvarsBat
+    return targetAbi() == msvcTc->targetAbi() && m_vcvarsBat == msvcTc->m_vcvarsBat
            && m_varsBatArg == msvcTc->m_varsBatArg;
 }
 
@@ -1795,12 +1840,12 @@ Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils:
     runEnv.unset(QLatin1String("ORIGINALPATH"));
     run.setEnvironment(runEnv.toStringList());
     run.setTimeoutS(30);
-    Utils::FileName cmdPath = Utils::FileName::fromUserInput(QString::fromLocal8Bit(qgetenv("COMSPEC")));
+    Utils::FileName cmdPath = Utils::FileName::fromUserInput(
+        QString::fromLocal8Bit(qgetenv("COMSPEC")));
     if (cmdPath.isEmpty())
         cmdPath = env.searchInPath(QLatin1String("cmd.exe"));
     // Windows SDK setup scripts require command line switches for environment expansion.
-    QStringList cmdArguments({
-        QLatin1String("/E:ON"), QLatin1String("/V:ON"), QLatin1String("/c")});
+    QStringList cmdArguments({QLatin1String("/E:ON"), QLatin1String("/V:ON"), QLatin1String("/c")});
     cmdArguments << QDir::toNativeSeparators(saver.fileName());
     if (debug)
         qDebug() << "readEnvironmentSetting: " << call << cmdPath << cmdArguments.join(' ')
@@ -1818,7 +1863,8 @@ Utils::optional<QString> MsvcToolChain::generateEnvironmentSettings(const Utils:
             command += ' ' + batchArgs;
         return QCoreApplication::translate("ProjectExplorer::Internal::MsvcToolChain",
                                            "Failed to retrieve MSVC Environment from \"%1\":\n"
-                                           "%2").arg(command, message);
+                                           "%2")
+            .arg(command, message);
     }
 
     // The SDK/MSVC scripts do not return exit codes != 0. Check on stdout.
@@ -1858,7 +1904,7 @@ bool MsvcToolChainFactory::canRestore(const QVariantMap &data)
     return id == Constants::MSVC_TOOLCHAIN_TYPEID;
 }
 
-template <class ToolChainType>
+template<class ToolChainType>
 ToolChainType *readFromMap(const QVariantMap &data)
 {
     auto result = new ToolChainType;
@@ -1904,12 +1950,11 @@ MsvcToolChain::WarningFlagAdder::WarningFlagAdder(const QString &flag, WarningFl
         m_triggered = true;
 }
 
-void MsvcToolChain::WarningFlagAdder::operator ()(int warningCode, WarningFlags flagsSet)
+void MsvcToolChain::WarningFlagAdder::operator()(int warningCode, WarningFlags flagsSet)
 {
     if (m_triggered)
         return;
-    if (warningCode == m_warningCode)
-    {
+    if (warningCode == m_warningCode) {
         m_triggered = true;
         if (m_doesEnable)
             m_flags |= flagsSet;
diff --git a/src/plugins/projectexplorer/msvctoolchain.h b/src/plugins/projectexplorer/msvctoolchain.h
index c2d6dbfb11f..f8cfefbead6 100644
--- a/src/plugins/projectexplorer/msvctoolchain.h
+++ b/src/plugins/projectexplorer/msvctoolchain.h
@@ -38,7 +38,9 @@
 QT_FORWARD_DECLARE_CLASS(QLabel)
 QT_FORWARD_DECLARE_CLASS(QVersionNumber)
 
-namespace Utils { class PathChooser; }
+namespace Utils {
+class PathChooser;
+}
 
 namespace ProjectExplorer {
 namespace Internal {
@@ -51,20 +53,14 @@ class MsvcToolChain : public ToolChain
 {
 public:
     enum Type { WindowsSDK, VS };
-    enum Platform { x86,
-                    amd64,
-                    x86_amd64,
-                    ia64,
-                    x86_ia64,
-                    arm,
-                    x86_arm,
-                    amd64_arm,
-                    amd64_x86
-                  };
+    enum Platform { x86, amd64, x86_amd64, ia64, x86_ia64, arm, x86_arm, amd64_arm, amd64_x86 };
 
-    explicit MsvcToolChain(const QString &name, const Abi &abi,
-                           const QString &varsBat, const QString &varsBatArg,
-                           Core::Id l, Detection d = ManualDetection);
+    explicit MsvcToolChain(const QString &name,
+                           const Abi &abi,
+                           const QString &varsBat,
+                           const QString &varsBatArg,
+                           Core::Id l,
+                           Detection d = ManualDetection);
     MsvcToolChain(const MsvcToolChain &other);
     MsvcToolChain();
     ~MsvcToolChain() override;
@@ -104,7 +100,7 @@ public:
     QString varsBat() const { return m_vcvarsBat; }
     void setVarsBatArg(const QString &varsBA) { m_varsBatArg = varsBA; }
 
-    bool operator == (const ToolChain &) const override;
+    bool operator==(const ToolChain &) const override;
 
     static void cancelMsvcToolChainDetection();
     static Utils::optional<QString> generateEnvironmentSettings(const Utils::Environment &env,
@@ -112,7 +108,6 @@ public:
                                                                 const QString &batchArgs,
                                                                 QMap<QString, QString> &envPairs);
 
-
 protected:
     class WarningFlagAdder
     {
@@ -120,22 +115,27 @@ protected:
         WarningFlags &m_flags;
         bool m_doesEnable = false;
         bool m_triggered = false;
+
     public:
         WarningFlagAdder(const QString &flag, WarningFlags &flags);
-        void operator ()(int warningCode, WarningFlags flagsSet);
+        void operator()(int warningCode, WarningFlags flagsSet);
 
         bool triggered() const;
     };
 
-    explicit MsvcToolChain(Core::Id typeId, const QString &name, const Abi &abi,
-                           const QString &varsBat, const QString &varsBatArg,
-                           Core::Id l, Detection d);
+    explicit MsvcToolChain(Core::Id typeId,
+                           const QString &name,
+                           const Abi &abi,
+                           const QString &varsBat,
+                           const QString &varsBatArg,
+                           Core::Id l,
+                           Detection d);
     explicit MsvcToolChain(Core::Id typeId);
 
     static void inferWarningsForLevel(int warningLevel, WarningFlags &flags);
     void toolChainUpdated() override;
 
-    Utils::Environment readEnvironmentSetting(const Utils::Environment& env) const;
+    Utils::Environment readEnvironmentSetting(const Utils::Environment &env) const;
     // Function must be thread-safe!
     virtual Macros msvcPredefinedMacros(const QStringList &cxxflags,
                                         const Utils::Environment &env) const;
@@ -149,7 +149,8 @@ protected:
         QList<Utils::EnvironmentItem> environmentItems;
     };
     static void environmentModifications(QFutureInterface<GenerateEnvResult> &future,
-                                         QString vcvarsBat, QString varsBatArg);
+                                         QString vcvarsBat,
+                                         QString varsBatArg);
     void initEnvModWatcher(const QFuture<GenerateEnvResult> &future);
 
 private:
@@ -177,9 +178,7 @@ protected:
 class ClangClToolChain : public MsvcToolChain
 {
 public:
-    ClangClToolChain(const QString &name, const QString &llvmDir,
-                     Core::Id language,
-                     Detection d);
+    ClangClToolChain(const QString &name, const QString &llvmDir, Core::Id language, Detection d);
     ClangClToolChain();
 
     bool isValid() const override;
@@ -204,7 +203,8 @@ public:
                                         const Core::Id &language,
                                         const Macros &macros) const override;
 
-    bool operator ==(const ToolChain &) const override;
+    bool operator==(const ToolChain &) const override;
+
 private:
     QString m_clangPath;
 };
@@ -226,7 +226,8 @@ public:
     bool canRestore(const QVariantMap &data) override;
     ToolChain *restore(const QVariantMap &data) override;
 
-    static QString vcVarsBatFor(const QString &basePath, MsvcToolChain::Platform platform,
+    static QString vcVarsBatFor(const QString &basePath,
+                                MsvcToolChain::Platform platform,
                                 const QVersionNumber &v);
 };
 
@@ -246,7 +247,6 @@ public:
     ToolChain *create(Core::Id l) override;
 };
 
-
 // --------------------------------------------------------------------------
 // MsvcBasedToolChainConfigWidget
 // --------------------------------------------------------------------------
@@ -259,10 +259,10 @@ public:
     explicit MsvcBasedToolChainConfigWidget(ToolChain *);
 
 protected:
-    void applyImpl() override { }
+    void applyImpl() override {}
     void discardImpl() override { setFromMsvcToolChain(); }
     bool isDirtyImpl() const override { return false; }
-    void makeReadOnlyImpl() override { }
+    void makeReadOnlyImpl() override {}
 
     void setFromMsvcToolChain();