Clang: Never use toolchain defines

The known cases provide enough flags not to require
toolchain defines.

Change-Id: Ia7e08a90eca6ea9474db40683ac1e63236f8643d
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>

src/plugins/clangcodemodel/clangutils.cpp

@@ -69,7 +69,6 @@ public:
     LibClangOptionsBuilder(const ProjectPart &projectPart)
         : CompilerOptionsBuilder(projectPart,
                                  UseSystemHeader::No,
-                                 useToolChainMacros(),
                                  UseTweakedHeaderPaths::Yes,
                                  UseLanguageDefines::No,
                                  QString(CLANG_VERSION),
@@ -77,10 +76,10 @@ public:
     {
     }
 
-    void addToolchainAndProjectMacros() final
+    void addProjectMacros() final
     {
         addMacros({ProjectExplorer::Macro("Q_CREATOR_RUN", "1")});
-        CompilerOptionsBuilder::addToolchainAndProjectMacros();
+        CompilerOptionsBuilder::addProjectMacros();
     }
 
     void addExtraOptions() final
@@ -339,7 +338,6 @@ void generateCompilationDB(::Utils::FileName projectDir, CppTools::ProjectInfo p
 
         CompilerOptionsBuilder optionsBuilder(*projectPart,
                                               UseSystemHeader::No,
-                                              UseToolchainMacros::No,
                                               UseTweakedHeaderPaths::No);
         optionsBuilder.build(CppTools::ProjectFile::Unclassified,
                              CppTools::UsePrecompiledHeaders::No);

src/plugins/clangtools/clangtoolruncontrol.cpp

@@ -193,7 +193,6 @@ static AnalyzeUnits toAnalyzeUnits(const FileInfos &fileInfos)
     for (const FileInfo &fileInfo : fileInfos) {
         CompilerOptionsBuilder optionsBuilder(*fileInfo.projectPart,
                                               UseSystemHeader::No,
-                                              CompilerOptionsBuilder::useToolChainMacros(),
                                               UseTweakedHeaderPaths::Yes,
                                               UseLanguageDefines::No,
                                               QString(CLANG_VERSION),

src/plugins/cpptools/compileroptionsbuilder.cpp

@@ -96,14 +96,12 @@ QStringList clangArgsForCl(const QStringList &args)
 
 CompilerOptionsBuilder::CompilerOptionsBuilder(const ProjectPart &projectPart,
                                                UseSystemHeader useSystemHeader,
-                                               UseToolchainMacros useToolchainMacros,
                                                UseTweakedHeaderPaths useTweakedHeaderPaths,
                                                UseLanguageDefines useLanguageDefines,
                                                const QString &clangVersion,
                                                const QString &clangResourceDirectory)
     : m_projectPart(projectPart)
     , m_useSystemHeader(useSystemHeader)
-    , m_useToolchainMacros(useToolchainMacros)
     , m_useTweakedHeaderPaths(useTweakedHeaderPaths)
     , m_useLanguageDefines(useLanguageDefines)
     , m_clangVersion(clangVersion)
@@ -141,12 +139,11 @@ QStringList CompilerOptionsBuilder::build(ProjectFile::Kind fileKind,
     addExtraCodeModelFlags();
 
     addMsvcCompatibilityVersion();
-    addToolchainAndProjectMacros();
+    addProjectMacros();
     undefineClangVersionMacrosForMsvc();
     undefineCppLanguageFeatureMacrosForMsvc2015();
     addDefineFunctionMacrosMsvc();
 
-    addToolchainFlags();
     addHeaderPathOptions();
 
     addExtraOptions();
@@ -330,10 +327,8 @@ void CompilerOptionsBuilder::addPrecompiledHeaderOptions(UsePrecompiledHeaders u
     }
 }
 
-void CompilerOptionsBuilder::addToolchainAndProjectMacros()
+void CompilerOptionsBuilder::addProjectMacros()
 {
-    if (m_useToolchainMacros == UseToolchainMacros::Yes)
-        addMacros(m_projectPart.toolChainMacros);
     addMacros(m_projectPart.projectMacros);
 }
 
@@ -662,16 +657,6 @@ void CompilerOptionsBuilder::addWrappedQtHeadersIncludePath(QStringList &list) c
     }
 }
 
-void CompilerOptionsBuilder::addToolchainFlags()
-{
-    // In case of MSVC we need builtin clang defines to correctly handle clang includes
-    if (m_projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID
-        && m_projectPart.toolchainType != ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID) {
-        if (m_useToolchainMacros == UseToolchainMacros::Yes)
-            add("-undef");
-    }
-}
-
 void CompilerOptionsBuilder::addProjectConfigFileInclude()
 {
     if (!m_projectPart.projectConfigFile.isEmpty()) {
@@ -701,12 +686,6 @@ void CompilerOptionsBuilder::undefineClangVersionMacrosForMsvc()
     }
 }
 
-UseToolchainMacros CompilerOptionsBuilder::useToolChainMacros()
-{
-    return qEnvironmentVariableIntValue("QTC_CLANG_USE_TOOLCHAIN_MACROS") ? UseToolchainMacros::Yes
-                                                                          : UseToolchainMacros::No;
-}
-
 void CompilerOptionsBuilder::reset()
 {
     m_options.clear();

src/plugins/cpptools/compileroptionsbuilder.h

@@ -45,7 +45,6 @@ class CPPTOOLS_EXPORT CompilerOptionsBuilder
 public:
     CompilerOptionsBuilder(const ProjectPart &projectPart,
                            UseSystemHeader useSystemHeader = UseSystemHeader::No,
-                           UseToolchainMacros useToolchainMacros = UseToolchainMacros::Yes,
                            UseTweakedHeaderPaths useTweakedHeaderPaths = UseTweakedHeaderPaths::Yes,
                            UseLanguageDefines useLanguageDefines = UseLanguageDefines::No,
                            const QString &clangVersion = QString(),
@@ -55,10 +54,9 @@ public:
     QStringList options() const { return m_options; }
 
     // Add options based on project part
-    virtual void addToolchainAndProjectMacros();
+    virtual void addProjectMacros();
     void addSyntaxOnly();
     void addWordWidth();
-    void addToolchainFlags();
     void addHeaderPathOptions();
     void addPrecompiledHeaderOptions(UsePrecompiledHeaders usePrecompiledHeaders);
     void addMacros(const ProjectExplorer::Macros &macros);
@@ -98,7 +96,6 @@ private:
     const ProjectPart &m_projectPart;
 
     const UseSystemHeader m_useSystemHeader;
-    const UseToolchainMacros m_useToolchainMacros;
     const UseTweakedHeaderPaths m_useTweakedHeaderPaths;
     const UseLanguageDefines m_useLanguageDefines;
 

tests/unit/unittest/compileroptionsbuilder-test.cpp

@@ -76,11 +76,11 @@ protected:
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart};
 };
 
-TEST_F(CompilerOptionsBuilder, AddToolchainAndProjectMacros)
+TEST_F(CompilerOptionsBuilder, AddProjectMacros)
 {
-    compilerOptionsBuilder.addToolchainAndProjectMacros();
+    compilerOptionsBuilder.addProjectMacros();
 
-    ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-Dfoo=bar", "-DprojectFoo=projectBar"));
+    ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-DprojectFoo=projectBar"));
 }
 
 TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_UnknownOptionsAreForwarded)
@@ -90,7 +90,6 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_UnknownOptionsAreForwarded
 
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::Yes};
 
@@ -106,7 +105,6 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_DiagnosticOptionsAreRemove
 
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::Yes};
 
@@ -126,7 +124,6 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_CLanguageVersionIsRewritte
 
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder{part,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::Yes};
 
@@ -140,7 +137,6 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_LanguageVersionIsExplicitl
 {
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::Yes};
 
@@ -154,7 +150,6 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_ClLanguageVersionIsExplici
     projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::Yes};
 
@@ -163,27 +158,6 @@ TEST_F(CompilerOptionsBuilder, CompilerFlagsFiltering_ClLanguageVersionIsExplici
     ASSERT_THAT(compilerOptionsBuilder.options(), Contains("/std:c++17"));
 }
 
-TEST_F(CompilerOptionsBuilder, AddToolchainAndProjectMacrosWithoutSkipingLanguageDefines)
-{
-    CppTools::CompilerOptionsBuilder compilerOptionsBuilder{projectPart,
-                                                            CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
-                                                            CppTools::UseTweakedHeaderPaths::Yes,
-                                                            CppTools::UseLanguageDefines::Yes};
-
-    compilerOptionsBuilder.addToolchainAndProjectMacros();
-
-    ASSERT_THAT(compilerOptionsBuilder.options(),
-                ElementsAre("-Dfoo=bar",
-                            "-D__cplusplus=2",
-                            "-D__STDC_VERSION__=2",
-                            "-D_MSVC_LANG=2",
-                            "-D_MSC_BUILD=2",
-                            "-D_MSC_FULL_VER=1900",
-                            "-D_MSC_VER=19",
-                            "-DprojectFoo=projectBar"));
-}
-
 TEST_F(CompilerOptionsBuilder, AddWordWidth)
 {
     compilerOptionsBuilder.addWordWidth();
@@ -191,13 +165,6 @@ TEST_F(CompilerOptionsBuilder, AddWordWidth)
     ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-m64"));
 }
 
-TEST_F(CompilerOptionsBuilder, AddToolchainFlags)
-{
-    compilerOptionsBuilder.addToolchainFlags();
-
-    ASSERT_THAT(compilerOptionsBuilder.options(), ElementsAre("-undef"));
-}
-
 TEST_F(CompilerOptionsBuilder, HeaderPathOptionsOrder)
 {
     compilerOptionsBuilder.addHeaderPathOptions();
@@ -240,7 +207,6 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersPath)
 {
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
                                                             "7.0.0",
@@ -270,7 +236,6 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderMacOs)
     projectPart.headerPaths.append(defaultPaths);
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
                                                             "7.0.0",
@@ -305,7 +270,6 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderLinux)
     projectPart.toolChainTargetTriple = "x86_64-linux-gnu";
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
                                                             "7.0.0",
@@ -339,7 +303,6 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderNoVersion)
     projectPart.toolChainTargetTriple = "x86_64-w64-windows-gnu";
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
                                                             "7.0.0",
@@ -387,7 +350,6 @@ TEST_F(CompilerOptionsBuilder, ClangHeadersAndCppIncludesPathsOrderAndroidClang)
     projectPart.toolChainTargetTriple = "i686-linux-android";
     CppTools::CompilerOptionsBuilder compilerOptionsBuilder(projectPart,
                                                             CppTools::UseSystemHeader::No,
-                                                            CppTools::UseToolchainMacros::Yes,
                                                             CppTools::UseTweakedHeaderPaths::Yes,
                                                             CppTools::UseLanguageDefines::No,
                                                             "7.0.0",
@@ -602,9 +564,7 @@ TEST_F(CompilerOptionsBuilder, BuildAllOptions)
                             "-std=c++17",
                             "-arch",
                             "x86_64",
-                            "-Dfoo=bar",
                             "-DprojectFoo=projectBar",
-                            "-undef",
                             "-I",
                             IsPartOfHeader("wrappedQtHeaders"),
                             "-I",
@@ -633,7 +593,6 @@ TEST_F(CompilerOptionsBuilder, BuildAllOptionsCl)
                             "/TP",
                             "/std:c++17",
                             "-fms-compatibility-version=19.00",
-                            "-Dfoo=bar",
                             "-DprojectFoo=projectBar",
                             "-D__FUNCSIG__=\"\"",
                             "-D__FUNCTION__=\"\"",