Clang: Allow to forward warnings flags from build system

Change-Id: I47ebb1ce4f3b5544408eb1d0f891ed5090394282
Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io>
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>

src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp

@@ -452,6 +452,10 @@ public:
 
     const QStringList &options() const { return m_options; }
     const Core::Id &diagnosticConfigId() const { return m_diagnosticConfigId; }
+    CppTools::UseBuildSystemWarnings useBuildSystemWarnings() const
+    {
+        return m_useBuildSystemWarnings;
+    }
 
 private:
     void addLanguageOptions()
@@ -491,6 +495,9 @@ private:
     void addDiagnosticOptionsForConfig(const CppTools::ClangDiagnosticConfig &diagnosticConfig)
     {
         m_diagnosticConfigId = diagnosticConfig.id();
+        m_useBuildSystemWarnings = diagnosticConfig.useBuildSystemWarnings()
+                                       ? CppTools::UseBuildSystemWarnings::Yes
+                                       : CppTools::UseBuildSystemWarnings::No;
 
         m_options.append(diagnosticConfig.clangOptions());
         addClangTidyOptions(diagnosticConfig);
@@ -565,6 +572,7 @@ private:
     const CppTools::ProjectPart &m_projectPart;
 
     Core::Id m_diagnosticConfigId;
+    CppTools::UseBuildSystemWarnings m_useBuildSystemWarnings = CppTools::UseBuildSystemWarnings::No;
     CppTools::CompilerOptionsBuilder m_builder;
     QStringList m_options;
 };
@@ -586,13 +594,13 @@ void ClangEditorDocumentProcessor::updateBackendDocument(CppTools::ProjectPart &
             return;
     }
 
-    const QStringList projectPartOptions = ClangCodeModel::Utils::createClangOptions(
-        projectPart,
-        CppTools::ProjectFile::Unsupported); // No language option as FileOptionsBuilder adds it.
-
     const FileOptionsBuilder fileOptions(filePath(), projectPart);
     m_diagnosticConfigId = fileOptions.diagnosticConfigId();
 
+    const QStringList projectPartOptions = ClangCodeModel::Utils::createClangOptions(
+        projectPart, fileOptions.useBuildSystemWarnings(),
+        CppTools::ProjectFile::Unsupported); // No language option as FileOptionsBuilder adds it.
+
     const QStringList compilationArguments = projectPartOptions + fileOptions.options();
 
     m_communicator.documentsOpened(

src/plugins/clangcodemodel/clangutils.cpp

@@ -66,11 +66,13 @@ namespace Utils {
 class LibClangOptionsBuilder final : public CompilerOptionsBuilder
 {
 public:
-    LibClangOptionsBuilder(const ProjectPart &projectPart)
+    LibClangOptionsBuilder(const ProjectPart &projectPart,
+                           UseBuildSystemWarnings useBuildSystemWarnings)
         : CompilerOptionsBuilder(projectPart,
                                  UseSystemHeader::No,
                                  UseTweakedHeaderPaths::Yes,
                                  UseLanguageDefines::No,
+                                 useBuildSystemWarnings,
                                  QString(CLANG_VERSION),
                                  QString(CLANG_RESOURCE_DIR))
     {
@@ -101,9 +103,12 @@ private:
     }
 };
 
-QStringList createClangOptions(const ProjectPart &projectPart, ProjectFile::Kind fileKind)
+QStringList createClangOptions(const ProjectPart &projectPart,
+                               UseBuildSystemWarnings useBuildSystemWarnings,
+                               ProjectFile::Kind fileKind)
 {
-    return LibClangOptionsBuilder(projectPart).build(fileKind, UsePrecompiledHeaders::No);
+    return LibClangOptionsBuilder(projectPart, useBuildSystemWarnings)
+        .build(fileKind, UsePrecompiledHeaders::No);
 }
 
 ProjectPart::Ptr projectPartForFile(const QString &filePath)

src/plugins/clangcodemodel/clangutils.h

@@ -28,6 +28,7 @@
 #include <cplusplus/Icons.h>
 
 #include <cpptools/projectpart.h>
+#include <cpptools/compileroptionsbuilder.h>
 
 #include <QTextCursor>
 
@@ -53,6 +54,7 @@ CppTools::CppEditorDocumentHandle *cppDocument(const QString &filePath);
 void setLastSentDocumentRevision(const QString &filePath, uint revision);
 
 QStringList createClangOptions(const CppTools::ProjectPart &projectPart,
+                               CppTools::UseBuildSystemWarnings useBuildSystemWarnings,
                                CppTools::ProjectFile::Kind fileKind);
 
 CppTools::ProjectPart::Ptr projectPartForFile(const QString &filePath);

src/plugins/clangtools/clangtoolruncontrol.cpp

@@ -195,6 +195,7 @@ static AnalyzeUnits toAnalyzeUnits(const FileInfos &fileInfos)
                                               UseSystemHeader::No,
                                               UseTweakedHeaderPaths::Yes,
                                               UseLanguageDefines::No,
+                                              UseBuildSystemWarnings::No,
                                               QString(CLANG_VERSION),
                                               QString(CLANG_RESOURCE_DIR));
         QStringList arguments = extraClangToolsPrependOptions();

src/plugins/cpptools/clangbasechecks.ui

@@ -24,6 +24,13 @@
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QCheckBox" name="useFlagsFromBuildSystemCheckBox">
+     <property name="text">
+      <string>Use diagnostic flags from build system</string>
+     </property>
+    </widget>
+   </item>
    <item>
     <widget class="CppTools::WrappableLineEdit" name="diagnosticOptionsTextEdit"/>
    </item>

src/plugins/cpptools/clangdiagnosticconfig.cpp

@@ -75,7 +75,8 @@ bool ClangDiagnosticConfig::operator==(const ClangDiagnosticConfig &other) const
         && m_clangTidyMode == other.m_clangTidyMode
         && m_clangTidyChecks == other.m_clangTidyChecks
         && m_clazyChecks == other.m_clazyChecks
-        && m_isReadOnly == other.m_isReadOnly;
+        && m_isReadOnly == other.m_isReadOnly
+        && m_useBuildSystemWarnings == other.m_useBuildSystemWarnings;
 }
 
 bool ClangDiagnosticConfig::operator!=(const ClangDiagnosticConfig &other) const
@@ -83,6 +84,16 @@ bool ClangDiagnosticConfig::operator!=(const ClangDiagnosticConfig &other) const
     return !(*this == other);
 }
 
+bool ClangDiagnosticConfig::useBuildSystemWarnings() const
+{
+    return m_useBuildSystemWarnings;
+}
+
+void ClangDiagnosticConfig::setUseBuildSystemWarnings(bool useBuildSystemWarnings)
+{
+    m_useBuildSystemWarnings = useBuildSystemWarnings;
+}
+
 ClangDiagnosticConfig::TidyMode ClangDiagnosticConfig::clangTidyMode() const
 {
     return m_clangTidyMode;

src/plugins/cpptools/clangdiagnosticconfig.h

@@ -65,6 +65,9 @@ public:
     bool isReadOnly() const;
     void setIsReadOnly(bool isReadOnly);
 
+    bool useBuildSystemWarnings() const;
+    void setUseBuildSystemWarnings(bool useBuildSystemWarnings);
+
     bool operator==(const ClangDiagnosticConfig &other) const;
     bool operator!=(const ClangDiagnosticConfig &other) const;
 
@@ -76,6 +79,7 @@ private:
     QString m_clangTidyChecks;
     QString m_clazyChecks;
     bool m_isReadOnly = false;
+    bool m_useBuildSystemWarnings = false;
 };
 
 using ClangDiagnosticConfigs = QVector<ClangDiagnosticConfig>;

src/plugins/cpptools/clangdiagnosticconfigsmodel.cpp

@@ -162,6 +162,18 @@ static void addConfigForTidyAndClazy(ClangDiagnosticConfigsModel &model)
     model.appendOrUpdate(config);
 }
 
+static void addConfigForBuildSystem(ClangDiagnosticConfigsModel &model)
+{
+    ClangDiagnosticConfig config;
+    config.setId("Builtin.BuildSystem");
+    config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
+                                                      "Build-systems' warnings"));
+    config.setIsReadOnly(true);
+    config.setUseBuildSystemWarnings(true);
+
+    model.appendOrUpdate(config);
+}
+
 static void addBuiltinConfigs(ClangDiagnosticConfigsModel &model)
 {
     addConfigForPedanticWarnings(model);
@@ -171,6 +183,7 @@ static void addBuiltinConfigs(ClangDiagnosticConfigsModel &model)
     addConfigForClangAnalyze(model);
     addConfigForClazy(model);
     addConfigForTidyAndClazy(model);
+    addConfigForBuildSystem(model);
 }
 
 ClangDiagnosticConfigsModel::ClangDiagnosticConfigsModel(const ClangDiagnosticConfigs &customConfigs)

src/plugins/cpptools/clangdiagnosticconfigswidget.cpp

@@ -38,6 +38,7 @@
 #include <projectexplorer/selectablefilesmodel.h>
 
 #include <utils/algorithm.h>
+#include <utils/executeondestruction.h>
 #include <utils/qtcassert.h>
 #include <utils/utilsicons.h>
 
@@ -611,7 +612,7 @@ ClangDiagnosticConfigsWidget::ClangDiagnosticConfigsWidget(const Core::Id &confi
             this, &ClangDiagnosticConfigsWidget::onCopyButtonClicked);
     connect(m_ui->removeButton, &QPushButton::clicked,
             this, &ClangDiagnosticConfigsWidget::onRemoveButtonClicked);
-    connectDiagnosticOptionsChanged();
+    connectClangOnlyOptionsChanged();
 
     connect(m_tidyChecks->checksPrefixesTree,
             &QTreeView::clicked,
@@ -734,14 +735,17 @@ static QStringList normalizeDiagnosticInputOptions(const QString &options)
     return options.simplified().split(QLatin1Char(' '), QString::SkipEmptyParts);
 }
 
-void ClangDiagnosticConfigsWidget::onDiagnosticOptionsEdited()
+void ClangDiagnosticConfigsWidget::onClangOnlyOptionsChanged()
 {
-    // Clean up input
+    const bool useBuildSystemWarnings = m_clangBaseChecks->useFlagsFromBuildSystemCheckBox
+                                            ->isChecked();
+
+    // Clean up options input
     const QString diagnosticOptions = m_clangBaseChecks->diagnosticOptionsTextEdit->document()
                                           ->toPlainText();
     const QStringList normalizedOptions = normalizeDiagnosticInputOptions(diagnosticOptions);
 
-    // Validate
+    // Validate options input
     const QString errorMessage = validateDiagnosticOptions(normalizedOptions);
     updateValidityWidgets(errorMessage);
     if (!errorMessage.isEmpty()) {
@@ -754,6 +758,7 @@ void ClangDiagnosticConfigsWidget::onDiagnosticOptionsEdited()
     // Commit valid changes
     ClangDiagnosticConfig updatedConfig = selectedConfig();
     updatedConfig.setClangOptions(normalizedOptions);
+    updatedConfig.setUseBuildSystemWarnings(useBuildSystemWarnings);
     updateConfig(updatedConfig);
 }
 
@@ -793,11 +798,17 @@ void ClangDiagnosticConfigsWidget::syncOtherWidgetsToComboBox()
     if (isConfigChooserEmpty())
         return;
 
+    disconnectClangOnlyOptionsChanged();
+    Utils::ExecuteOnDestruction e([this]() { connectClangOnlyOptionsChanged(); });
+
     const ClangDiagnosticConfig &config = selectedConfig();
 
     // Update main button row
     m_ui->removeButton->setEnabled(!config.isReadOnly());
 
+    // Update check box
+    m_clangBaseChecks->useFlagsFromBuildSystemCheckBox->setChecked(config.useBuildSystemWarnings());
+
     // Update Text Edit
     const QString options = m_notAcceptedOptions.contains(config.id())
             ? m_notAcceptedOptions.value(config.id())
@@ -894,11 +905,8 @@ bool ClangDiagnosticConfigsWidget::isConfigChooserEmpty() const
 
 void ClangDiagnosticConfigsWidget::setDiagnosticOptions(const QString &options)
 {
-    if (options != m_clangBaseChecks->diagnosticOptionsTextEdit->document()->toPlainText()) {
+    if (options != m_clangBaseChecks->diagnosticOptionsTextEdit->document()->toPlainText())
-        disconnectDiagnosticOptionsChanged();
         m_clangBaseChecks->diagnosticOptionsTextEdit->document()->setPlainText(options);
-        connectDiagnosticOptionsChanged();
-    }
 
     const QString errorMessage
             = validateDiagnosticOptions(normalizeDiagnosticInputOptions(options));
@@ -968,20 +976,28 @@ void ClangDiagnosticConfigsWidget::disconnectConfigChooserCurrentIndex()
                this, &ClangDiagnosticConfigsWidget::onCurrentConfigChanged);
 }
 
-void ClangDiagnosticConfigsWidget::connectDiagnosticOptionsChanged()
+void ClangDiagnosticConfigsWidget::connectClangOnlyOptionsChanged()
 {
+    connect(m_clangBaseChecks->useFlagsFromBuildSystemCheckBox,
+            &QCheckBox::stateChanged,
+            this,
+            &ClangDiagnosticConfigsWidget::onClangOnlyOptionsChanged);
     connect(m_clangBaseChecks->diagnosticOptionsTextEdit->document(),
             &QTextDocument::contentsChanged,
             this,
-            &ClangDiagnosticConfigsWidget::onDiagnosticOptionsEdited);
+            &ClangDiagnosticConfigsWidget::onClangOnlyOptionsChanged);
 }
 
-void ClangDiagnosticConfigsWidget::disconnectDiagnosticOptionsChanged()
+void ClangDiagnosticConfigsWidget::disconnectClangOnlyOptionsChanged()
 {
+    disconnect(m_clangBaseChecks->useFlagsFromBuildSystemCheckBox,
+               &QCheckBox::stateChanged,
+               this,
+               &ClangDiagnosticConfigsWidget::onClangOnlyOptionsChanged);
     disconnect(m_clangBaseChecks->diagnosticOptionsTextEdit->document(),
                &QTextDocument::contentsChanged,
                this,
-               &ClangDiagnosticConfigsWidget::onDiagnosticOptionsEdited);
+               &ClangDiagnosticConfigsWidget::onClangOnlyOptionsChanged);
 }
 
 ClangDiagnosticConfigs ClangDiagnosticConfigsWidget::customConfigs() const

src/plugins/cpptools/clangdiagnosticconfigswidget.h

@@ -77,7 +77,7 @@ private:
     void onClazyTreeChanged();
     void onClangTidyTreeItemClicked(const QModelIndex &index);
 
-    void onDiagnosticOptionsEdited();
+    void onClangOnlyOptionsChanged();
 
     void syncWidgetsToModel(const Core::Id &configToSelect = Core::Id());
     void syncConfigChooserToModel(const Core::Id &configToSelect = Core::Id());
@@ -104,8 +104,8 @@ private:
 
     void connectConfigChooserCurrentIndex();
     void disconnectConfigChooserCurrentIndex();
-    void connectDiagnosticOptionsChanged();
+    void connectClangOnlyOptionsChanged();
-    void disconnectDiagnosticOptionsChanged();
+    void disconnectClangOnlyOptionsChanged();
 
 private:
     Ui::ClangDiagnosticConfigsWidget *m_ui;

src/plugins/cpptools/compileroptionsbuilder.cpp

@@ -99,12 +99,14 @@ CompilerOptionsBuilder::CompilerOptionsBuilder(const ProjectPart &projectPart,
                                                UseSystemHeader useSystemHeader,
                                                UseTweakedHeaderPaths useTweakedHeaderPaths,
                                                UseLanguageDefines useLanguageDefines,
+                                               UseBuildSystemWarnings useBuildSystemWarnings,
                                                const QString &clangVersion,
                                                const QString &clangResourceDirectory)
     : m_projectPart(projectPart)
     , m_useSystemHeader(useSystemHeader)
     , m_useTweakedHeaderPaths(useTweakedHeaderPaths)
     , m_useLanguageDefines(useLanguageDefines)
+    , m_useBuildSystemWarnings(useBuildSystemWarnings)
     , m_clangVersion(clangVersion)
     , m_clangResourceDirectory(clangResourceDirectory)
 {
@@ -707,10 +709,11 @@ void CompilerOptionsBuilder::evaluateCompilerFlags()
             continue;
         }
 
-        // Ignore warning flags as these interfere with ouser user-configured diagnostics.
+        // Ignore warning flags as these interfere with our user-configured diagnostics.
         // Note that once "-w" is provided, no warnings will be emitted, even if "-Wall" follows.
-        if (option.startsWith("-w", Qt::CaseInsensitive)
+        if (m_useBuildSystemWarnings == UseBuildSystemWarnings::No
-            || option.startsWith("/w", Qt::CaseInsensitive) || option.startsWith("-pedantic")) {
+            && (option.startsWith("-w", Qt::CaseInsensitive)
+                || option.startsWith("/w", Qt::CaseInsensitive) || option.startsWith("-pedantic"))) {
             // -w, -W, /w, /W...
             continue;
         }

src/plugins/cpptools/compileroptionsbuilder.h

@@ -36,6 +36,7 @@ enum class UseSystemHeader : char { Yes, No };
 enum class UseTweakedHeaderPaths : char { Yes, No };
 enum class UseToolchainMacros : char { Yes, No };
 enum class UseLanguageDefines : char { Yes, No };
+enum class UseBuildSystemWarnings : char { Yes, No };
 
 CPPTOOLS_EXPORT QStringList XclangArgs(const QStringList &args);
 CPPTOOLS_EXPORT QStringList clangArgsForCl(const QStringList &args);
@@ -43,12 +44,14 @@ CPPTOOLS_EXPORT QStringList clangArgsForCl(const QStringList &args);
 class CPPTOOLS_EXPORT CompilerOptionsBuilder
 {
 public:
-    CompilerOptionsBuilder(const ProjectPart &projectPart,
+    CompilerOptionsBuilder(
-                           UseSystemHeader useSystemHeader = UseSystemHeader::No,
+        const ProjectPart &projectPart,
-                           UseTweakedHeaderPaths useTweakedHeaderPaths = UseTweakedHeaderPaths::No,
+        UseSystemHeader useSystemHeader = UseSystemHeader::No,
-                           UseLanguageDefines useLanguageDefines = UseLanguageDefines::No,
+        UseTweakedHeaderPaths useTweakedHeaderPaths = UseTweakedHeaderPaths::No,
-                           const QString &clangVersion = QString(),
+        UseLanguageDefines useLanguageDefines = UseLanguageDefines::No,
-                           const QString &clangResourceDirectory = QString());
+        UseBuildSystemWarnings useBuildSystemWarnings = UseBuildSystemWarnings::No,
+        const QString &clangVersion = QString(),
+        const QString &clangResourceDirectory = QString());
 
     QStringList build(ProjectFile::Kind fileKind, UsePrecompiledHeaders usePrecompiledHeaders);
     QStringList options() const { return m_options; }
@@ -99,6 +102,7 @@ private:
     const UseSystemHeader m_useSystemHeader;
     const UseTweakedHeaderPaths m_useTweakedHeaderPaths;
     const UseLanguageDefines m_useLanguageDefines;
+    const UseBuildSystemWarnings m_useBuildSystemWarnings;
 
     const QString m_clangVersion;
     const QString m_clangResourceDirectory;

tests/unit/unittest/compileroptionsbuilder-test.cpp

@@ -98,6 +98,22 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_UnknownOptionsAreForwarded
     ASSERT_THAT(compilerOptionsBuilder.options(), Contains(part.compilerFlags.first()));
 }
 
+TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_WarningsFlagsAreNotFilteredIfRequested)
+{
+    ProjectPart part = projectPart;
+    part.compilerFlags = QStringList{"-Whello"};
+
+    CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
+                                                            CppTools::UseSystemHeader::No,
+                                                            CppTools::UseTweakedHeaderPaths::No,
+                                                            CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::Yes};
+
+    compilerOptionsBuilder.build(ProjectFile::CXXSource, CppTools::UsePrecompiledHeaders::No);
+
+    ASSERT_THAT(compilerOptionsBuilder.options(), Contains(part.compilerFlags.first()));
+}
+
 TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_DiagnosticOptionsAreRemoved)
 {
     ProjectPart part = projectPart;
@@ -171,6 +187,7 @@ TEST_F(CompilerOptionsBuilder, HeaderPathOptionsOrder)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             ""};
 
@@ -196,6 +213,7 @@ TEST_F(CompilerOptionsBuilder, HeaderPathOptionsOrderCl)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             ""};
     compilerOptionsBuilder.evaluateCompilerFlags();
@@ -221,6 +239,7 @@ TEST_F(CompilerOptionsBuilder, UseSystemHeader)
                                                             CppTools::UseSystemHeader::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             ""};
 
@@ -265,6 +284,7 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderMacOs)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             "");
 
@@ -310,6 +330,7 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderLinux)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             "");
 
@@ -356,6 +377,7 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderNoVersion)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             "");
 
@@ -403,6 +425,7 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderAndroidClang)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             "");
 
@@ -480,6 +503,7 @@ TEST_F(CompilerOptionsBuilder, InsertWrappedQtHeaders)
                                                             CppTools::UseSystemHeader::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             ""};
 
@@ -613,6 +637,7 @@ TEST_F(CompilerOptionsBuilder, BuildAllOptions)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             "");
 
@@ -652,6 +677,7 @@ TEST_F(CompilerOptionsBuilder, BuildAllOptionsCl)
                                                             CppTools::UseSystemHeader::No,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
+                                                            CppTools::UseBuildSystemWarnings::No,
                                                             "dummy_version",
                                                             "");