From 68a49c79da0ae709e2e4e0fd6584587a6e2d8473 Mon Sep 17 00:00:00 2001 From: Ivan Donchevskii Date: Mon, 11 Sep 2017 14:08:00 +0200 Subject: [PATCH] Clang: Unify compiler options builders Make build command the same for all builders. Minimize differences. Change-Id: I1cfe5071b3afb4944ed178fff1e57d3aee45d8a9 Reviewed-by: Nikolai Kosjar --- scripts/deployqt.py | 2 - src/plugins/clangcodemodel/clangutils.cpp | 47 ++--- .../clangpchmanager/projectupdater.cpp | 32 +--- .../clangqueryprojectsfindfilter.cpp | 27 +-- .../clangrefactoring/refactoringengine.cpp | 8 +- ...taticanalyzerpreconfiguredsessiontests.cpp | 2 +- .../clangstaticanalyzerruncontrol.cpp | 170 +++--------------- .../clangstaticanalyzerunittests.cpp | 2 +- .../clangstaticanalyzerutils.cpp | 10 +- .../clangstaticanalyzerutils.h | 2 +- .../cpptools/clangcompileroptionsbuilder.cpp | 117 ++++++------ .../cpptools/clangcompileroptionsbuilder.h | 27 +-- .../cpptools/compileroptionsbuilder.cpp | 17 +- src/plugins/cpptools/compileroptionsbuilder.h | 4 +- .../unit/unittest/refactoringengine-test.cpp | 10 +- 15 files changed, 120 insertions(+), 357 deletions(-) diff --git a/scripts/deployqt.py b/scripts/deployqt.py index 8e7fa8ba47a..5559587f990 100755 --- a/scripts/deployqt.py +++ b/scripts/deployqt.py @@ -223,8 +223,6 @@ def deploy_libclang(install_dir, llvm_install_dir, chrpath_bin): os.path.join(install_dir, 'bin'))) deployinfo.append((os.path.join(llvm_install_dir, 'bin', 'clang.exe'), clangbindirtarget)) - deployinfo.append((os.path.join(llvm_install_dir, 'bin', 'clang-cl.exe'), - clangbindirtarget)) resourcetarget = os.path.join(clanglibdirtarget, 'clang') else: libsources = glob(os.path.join(llvm_install_dir, 'lib', 'libclang.so*')) diff --git a/src/plugins/clangcodemodel/clangutils.cpp b/src/plugins/clangcodemodel/clangutils.cpp index e436ec275fb..0058ee4023b 100644 --- a/src/plugins/clangcodemodel/clangutils.cpp +++ b/src/plugins/clangcodemodel/clangutils.cpp @@ -70,46 +70,21 @@ QStringList createClangOptions(const ProjectPart::Ptr &pPart, const QString &fil return createClangOptions(pPart, fileKind); } -class LibClangOptionsBuilder : public ClangCompilerOptionsBuilder +class LibClangOptionsBuilder final : public ClangCompilerOptionsBuilder { public: - static QStringList build(const ProjectPart::Ptr &projectPart, ProjectFile::Kind fileKind) - { - if (projectPart.isNull()) - return QStringList(); - - LibClangOptionsBuilder optionsBuilder(*projectPart.data()); - - optionsBuilder.addWordWidth(); - optionsBuilder.addTargetTriple(); - optionsBuilder.addLanguageOption(fileKind); - optionsBuilder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true); - optionsBuilder.enableExceptions(); - - optionsBuilder.addDefineToAvoidIncludingGccOrMinGwIntrinsics(); - optionsBuilder.addDefineFloat128ForMingw(); - optionsBuilder.addToolchainAndProjectDefines(); - optionsBuilder.undefineCppLanguageFeatureMacrosForMsvc2015(); - - optionsBuilder.addPredefinedMacrosAndHeaderPathsOptions(); - optionsBuilder.addWrappedQtHeadersIncludePath(); - optionsBuilder.addHeaderPathOptions(); - optionsBuilder.addDummyUiHeaderOnDiskIncludePath(); - optionsBuilder.addProjectConfigFileInclude(); - - optionsBuilder.addMsvcCompatibilityVersion(); - - optionsBuilder.addExtraOptions(); - - return optionsBuilder.options(); - } - -private: - LibClangOptionsBuilder(const CppTools::ProjectPart &projectPart) + LibClangOptionsBuilder(const ProjectPart &projectPart) : ClangCompilerOptionsBuilder(projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR) { } + void addExtraOptions() final + { + addDummyUiHeaderOnDiskIncludePath(); + ClangCompilerOptionsBuilder::addExtraOptions(); + } + +private: void addDummyUiHeaderOnDiskIncludePath() { const QString path = ModelManagerSupportClang::instance()->dummyUiHeaderOnDiskDirPath(); @@ -125,7 +100,9 @@ private: */ QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind fileKind) { - return LibClangOptionsBuilder::build(pPart, fileKind); + if (!pPart) + return QStringList(); + return LibClangOptionsBuilder(*pPart).build(fileKind, CompilerOptionsBuilder::PchUsage::None); } ProjectPart::Ptr projectPartForFile(const QString &filePath) diff --git a/src/plugins/clangpchmanager/projectupdater.cpp b/src/plugins/clangpchmanager/projectupdater.cpp index 046c5f769fc..8327f85a221 100644 --- a/src/plugins/clangpchmanager/projectupdater.cpp +++ b/src/plugins/clangpchmanager/projectupdater.cpp @@ -108,35 +108,9 @@ HeaderAndSources ProjectUpdater::headerAndSourcesFromProjectPart( QStringList ProjectUpdater::compilerArguments(CppTools::ProjectPart *projectPart) { - using CppTools::ClangCompilerOptionsBuilder; - - ClangCompilerOptionsBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR); - - builder.addWordWidth(); - builder.addTargetTriple(); - builder.addLanguageOption(CppTools::ProjectFile::CXXHeader); - builder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true); - builder.enableExceptions(); - - builder.addDefineToAvoidIncludingGccOrMinGwIntrinsics(); - builder.addDefineFloat128ForMingw(); - builder.addToolchainAndProjectDefines(); - builder.undefineCppLanguageFeatureMacrosForMsvc2015(); - - builder.addPredefinedMacrosAndHeaderPathsOptions(); - builder.addWrappedQtHeadersIncludePath(); - builder.addPrecompiledHeaderOptions(ClangCompilerOptionsBuilder::PchUsage::None); - builder.addHeaderPathOptions(); - builder.addProjectConfigFileInclude(); - - builder.addMsvcCompatibilityVersion(); - - builder.add("-fmessage-length=0"); - builder.add("-fmacro-backtrace-limit=0"); - builder.add("-w"); - builder.add("-ferror-limit=100000"); - - return builder.options(); + using ClangCOBuilder = CppTools::ClangCompilerOptionsBuilder; + ClangCOBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR); + return builder.build(CppTools::ProjectFile::CXXHeader, ClangCOBuilder::PchUsage::None); } ClangBackEnd::V2::ProjectPartContainer ProjectUpdater::toProjectPartContainer( diff --git a/src/plugins/clangrefactoring/clangqueryprojectsfindfilter.cpp b/src/plugins/clangrefactoring/clangqueryprojectsfindfilter.cpp index d4e210c04e8..14d8a1620ec 100644 --- a/src/plugins/clangrefactoring/clangqueryprojectsfindfilter.cpp +++ b/src/plugins/clangrefactoring/clangqueryprojectsfindfilter.cpp @@ -155,31 +155,8 @@ Utils::SmallStringVector ClangQueryProjectsFindFilter::compilerArguments(CppTool ClangCompilerOptionsBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR); - builder.addWordWidth(); - builder.addTargetTriple(); - builder.addLanguageOption(fileKind); - builder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true); - builder.enableExceptions(); - - builder.addDefineToAvoidIncludingGccOrMinGwIntrinsics(); - builder.addDefineFloat128ForMingw(); - builder.addToolchainAndProjectDefines(); - builder.undefineCppLanguageFeatureMacrosForMsvc2015(); - - builder.addPredefinedMacrosAndHeaderPathsOptions(); - builder.addWrappedQtHeadersIncludePath(); - builder.addPrecompiledHeaderOptions(ClangCompilerOptionsBuilder::PchUsage::None); - builder.addHeaderPathOptions(); - builder.addProjectConfigFileInclude(); - - builder.addMsvcCompatibilityVersion(); - - builder.add("-fmessage-length=0"); - builder.add("-fmacro-backtrace-limit=0"); - builder.add("-w"); - builder.add("-ferror-limit=1000000"); - - return Utils::SmallStringVector(builder.options()); + return Utils::SmallStringVector(builder.build(fileKind, + ClangCompilerOptionsBuilder::PchUsage::None)); } QWidget *ClangQueryProjectsFindFilter::widget() const diff --git a/src/plugins/clangrefactoring/refactoringengine.cpp b/src/plugins/clangrefactoring/refactoringengine.cpp index 1d964fe8938..696e38c468c 100644 --- a/src/plugins/clangrefactoring/refactoringengine.cpp +++ b/src/plugins/clangrefactoring/refactoringengine.cpp @@ -64,12 +64,10 @@ void RefactoringEngine::startLocalRenaming(const CppTools::CursorInEditor &data, QString filePath = data.filePath().toString(); QTextCursor textCursor = data.cursor(); - Utils::SmallStringVector commandLine{ClangCompilerOptionsBuilder::build( - projectPart, + ClangCompilerOptionsBuilder clangCOBuilder{*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR}; + Utils::SmallStringVector commandLine{clangCOBuilder.build( fileKindInProjectPart(projectPart, filePath), - CppTools::getPchUsage(), - CLANG_VERSION, - CLANG_RESOURCE_DIR)}; + CppTools::getPchUsage())}; commandLine.push_back(filePath); diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp index 0cb7c976ee1..c9ff00558db 100644 --- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp +++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp @@ -167,7 +167,7 @@ static QList validTargets(Project *project) const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID); QTC_ASSERT(toolchain, return false); bool hasClangExecutable; - clangExecutableFromSettings(toolchain->typeId(), &hasClangExecutable); + clangExecutableFromSettings(&hasClangExecutable); if (!hasClangExecutable) { qWarning("Project \"%s\": Skipping target \"%s\" since no suitable clang was found for the toolchain.", qPrintable(projectFileName), diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp index 0cfafa08e11..94468e913e4 100644 --- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp +++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp @@ -38,7 +38,7 @@ #include #include -#include +#include #include #include #include @@ -161,8 +161,7 @@ static void prependTargetTripleIfNotIncludedAndNotEmpty(QStringList *arguments, } // Removes (1) inputFile (2) -o . -QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStringList &arguments, - bool isMsvc) +QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStringList &arguments) { QStringList newArguments; @@ -174,9 +173,6 @@ QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStri } else if (argument == QLatin1String("-o")) { skip = true; continue; - } else if (isMsvc && argument == QLatin1String("-target")) { - skip = true; - continue; } else if (QDir::fromNativeSeparators(argument) == inputFile) { continue; // TODO: Let it in? } @@ -188,55 +184,11 @@ QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStri return newArguments; } -static QString createLanguageOptionMsvc(ProjectFile::Kind fileKind) -{ - switch (fileKind) { - case ProjectFile::CHeader: - case ProjectFile::CSource: - return QLatin1String("/TC"); - break; - case ProjectFile::CXXHeader: - case ProjectFile::CXXSource: - return QLatin1String("/TP"); - break; - default: - break; - } - return QString(); -} - -class ClangStaticAnalyzerOptionsBuilder : public CompilerOptionsBuilder +class ClangStaticAnalyzerOptionsBuilder final : public ClangCompilerOptionsBuilder { public: - static QStringList build(const CppTools::ProjectPart &projectPart, - CppTools::ProjectFile::Kind fileKind, - PchUsage pchUsage) - { - ClangStaticAnalyzerOptionsBuilder optionsBuilder(projectPart); - - optionsBuilder.addWordWidth(); - optionsBuilder.addTargetTriple(); - optionsBuilder.addLanguageOption(fileKind); - optionsBuilder.addOptionsForLanguage(false); - optionsBuilder.enableExceptions(); - - optionsBuilder.addDefineFloat128ForMingw(); - optionsBuilder.addDefineToAvoidIncludingGccOrMinGwIntrinsics(); - const Core::Id type = projectPart.toolchainType; - if (type != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) - optionsBuilder.addMacros(projectPart.toolChainMacros); - optionsBuilder.addMacros(projectPart.projectMacros); - optionsBuilder.undefineClangVersionMacrosForMsvc(); - optionsBuilder.undefineCppLanguageFeatureMacrosForMsvc2015(); - optionsBuilder.addHeaderPathOptions(); - optionsBuilder.addPrecompiledHeaderOptions(pchUsage); - optionsBuilder.addMsvcCompatibilityVersion(); - - return optionsBuilder.options(); - } - ClangStaticAnalyzerOptionsBuilder(const CppTools::ProjectPart &projectPart) - : CompilerOptionsBuilder(projectPart) + : ClangCompilerOptionsBuilder(projectPart) , m_isMsvcToolchain(m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) , m_isMinGWToolchain(m_projectPart.toolchainType @@ -244,91 +196,28 @@ public: { } -public: - bool excludeHeaderPath(const QString &headerPath) const override + bool excludeHeaderPath(const QString &headerPath) const final { - if (CompilerOptionsBuilder::excludeHeaderPath(headerPath)) - return true; if (m_isMinGWToolchain && headerPath.contains(m_projectPart.toolChainTargetTriple)) return true; - return false; + return ClangCompilerOptionsBuilder::excludeHeaderPath(headerPath); } - void undefineClangVersionMacrosForMsvc() + void addPredefinedHeaderPathsOptions() final { - if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { - static QStringList macroNames { - "__clang__", - "__clang_major__", - "__clang_minor__", - "__clang_patchlevel__", - "__clang_version__" - }; - - foreach (const QString ¯oName, macroNames) - add(QLatin1String("/U") + macroName); + add("-undef"); + if (m_isMsvcToolchain) { + // exclude default clang path to use msvc includes + add("-nostdinc"); + add("-nostdlibinc"); } } -private: - void addTargetTriple() override - { - // For MSVC toolchains we use clang-cl.exe, so there is nothing to do here since - // 1) clang-cl.exe does not understand the "-triple" option - // 2) clang-cl.exe already hardcodes the right triple value (even if built with mingw) - if (!m_isMsvcToolchain) - CompilerOptionsBuilder::addTargetTriple(); - } + void addExtraOptions() final {} - void addLanguageOption(ProjectFile::Kind fileKind) override + void addWrappedQtHeadersIncludePath() final { - if (m_isMsvcToolchain) - add(createLanguageOptionMsvc(fileKind)); - else - CompilerOptionsBuilder::addLanguageOption(fileKind); - } - - void addOptionsForLanguage(bool checkForBorlandExtensions) override - { - if (m_isMsvcToolchain) - return; - CompilerOptionsBuilder::addOptionsForLanguage(checkForBorlandExtensions); - } - - QString includeOption() const override - { - if (m_isMsvcToolchain) - return QLatin1String("/FI"); - return CompilerOptionsBuilder::includeOption(); - } - - QString includeDirOption() const override - { - if (m_isMsvcToolchain) - return QLatin1String("/I"); - return CompilerOptionsBuilder::includeDirOption(); - } - - QString defineOption() const override - { - if (m_isMsvcToolchain) - return QLatin1String("/D"); - return CompilerOptionsBuilder::defineOption(); - } - - QString undefineOption() const override - { - if (m_isMsvcToolchain) - return QLatin1String("/U"); - return CompilerOptionsBuilder::undefineOption(); - } - - void enableExceptions() override - { - if (m_isMsvcToolchain) - add(QLatin1String("/EHsc")); - else - CompilerOptionsBuilder::enableExceptions(); + // Empty, analyzer doesn't need them } private: @@ -383,7 +272,7 @@ static QStringList tweakedArguments(const ProjectPart &projectPart, { const bool isMsvc = projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID; - QStringList newArguments = inputAndOutputArgumentsRemoved(filePath, arguments, isMsvc); + QStringList newArguments = inputAndOutputArgumentsRemoved(filePath, arguments); prependWordWidthArgumentIfNotIncluded(&newArguments, projectPart.toolChainWordWidth); if (!isMsvc) prependTargetTripleIfNotIncludedAndNotEmpty(&newArguments, targetTriple); @@ -434,7 +323,7 @@ static AnalyzeUnits unitsToAnalyzeFromProjectParts(const QVectorselectedForBuilding) + if (!projectPart->selectedForBuilding || !projectPart.data()) continue; foreach (const ProjectFile &file, projectPart->files) { @@ -445,7 +334,7 @@ static AnalyzeUnits unitsToAnalyzeFromProjectParts(const QVectortypeId(), &hasClangExecutable); + clangExecutableFromSettings(&hasClangExecutable); if (!hasClangExecutable) QSKIP("No clang suitable for analyzing found"); diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.cpp index 073adac6798..7a433aac49f 100644 --- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.cpp +++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.cpp @@ -50,7 +50,7 @@ static bool isFileExecutable(const QString &executablePath) namespace ClangStaticAnalyzer { namespace Internal { -QString clangExecutableFromSettings(Core::Id toolchainType, bool *isValid) +QString clangExecutableFromSettings(bool *isValid) { QString executable = ClangStaticAnalyzerSettings::instance()->clangExecutable(); if (executable.isEmpty()) { @@ -62,14 +62,6 @@ QString clangExecutableFromSettings(Core::Id toolchainType, bool *isValid) const Qt::CaseSensitivity caseSensitivity = Utils::HostOsInfo::fileNameCaseSensitivity(); const bool hasSuffix = executable.endsWith(hostExeSuffix, caseSensitivity); - if (toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { - if (hasSuffix) - executable.chop(hostExeSuffix.length()); - executable.append(QLatin1String("-cl")); - if (hasSuffix) - executable.append(hostExeSuffix); - } - const QFileInfo fileInfo = QFileInfo(executable); if (fileInfo.isAbsolute()) { if (!hasSuffix) diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.h b/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.h index e170d8b7f01..c18317237c6 100644 --- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.h +++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.h @@ -41,7 +41,7 @@ namespace Internal { bool isClangExecutableUsable(const QString &filePath, QString *errorMessage = 0); -QString clangExecutableFromSettings(Core::Id toolchainType, bool *isValid); +QString clangExecutableFromSettings(bool *isValid); QString createFullLocationString(const Debugger::DiagnosticLocation &location); diff --git a/src/plugins/cpptools/clangcompileroptionsbuilder.cpp b/src/plugins/cpptools/clangcompileroptionsbuilder.cpp index 160bf6b4c6c..0b2209cc628 100644 --- a/src/plugins/cpptools/clangcompileroptionsbuilder.cpp +++ b/src/plugins/cpptools/clangcompileroptionsbuilder.cpp @@ -26,7 +26,6 @@ #include "clangcompileroptionsbuilder.h" #include - #include #include @@ -37,6 +36,15 @@ namespace CppTools { static QString creatorResourcePath() { +#ifndef UNIT_TESTS + return Core::ICore::instance()->resourcePath(); +#else + return QString(); +#endif +} + +static QString creatorLibexecPath() +{ #ifndef UNIT_TESTS return Core::ICore::instance()->libexecPath(); #else @@ -44,40 +52,31 @@ static QString creatorResourcePath() #endif } -QStringList ClangCompilerOptionsBuilder::build(const CppTools::ProjectPart *projectPart, - CppTools::ProjectFile::Kind fileKind, - PchUsage pchUsage, - const QString &clangVersion, - const QString &clangResourceDirectory) +QStringList ClangCompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, + PchUsage pchUsage) { - if (projectPart) { - ClangCompilerOptionsBuilder builder(*projectPart, clangVersion, clangResourceDirectory); + addWordWidth(); + addTargetTriple(); + addLanguageOption(fileKind); + addOptionsForLanguage(/*checkForBorlandExtensions*/ true); + enableExceptions(); - builder.addWordWidth(); - builder.addTargetTriple(); - builder.addLanguageOption(fileKind); - builder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true); - builder.enableExceptions(); + addDefineFloat128ForMingw(); + addToolchainAndProjectMacros(); + undefineClangVersionMacrosForMsvc(); + undefineCppLanguageFeatureMacrosForMsvc2015(); - builder.addDefineToAvoidIncludingGccOrMinGwIntrinsics(); - builder.addDefineFloat128ForMingw(); - builder.addToolchainAndProjectDefines(); - builder.undefineCppLanguageFeatureMacrosForMsvc2015(); + addPredefinedHeaderPathsOptions(); + addWrappedQtHeadersIncludePath(); + addPrecompiledHeaderOptions(pchUsage); + addHeaderPathOptions(); + addProjectConfigFileInclude(); - builder.addPredefinedMacrosAndHeaderPathsOptions(); - builder.addWrappedQtHeadersIncludePath(); - builder.addPrecompiledHeaderOptions(pchUsage); - builder.addHeaderPathOptions(); - builder.addProjectConfigFileInclude(); + addMsvcCompatibilityVersion(); - builder.addMsvcCompatibilityVersion(); + addExtraOptions(); - builder.addExtraOptions(); - - return builder.options(); - } - - return QStringList(); + return options(); } ClangCompilerOptionsBuilder::ClangCompilerOptionsBuilder(const CppTools::ProjectPart &projectPart, @@ -91,47 +90,35 @@ ClangCompilerOptionsBuilder::ClangCompilerOptionsBuilder(const CppTools::Project bool ClangCompilerOptionsBuilder::excludeHeaderPath(const QString &path) const { - if (m_projectPart.toolchainType == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) { - if (path.contains("lib/gcc/i686-apple-darwin")) - return true; + if (m_projectPart.toolchainType == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID + && path.contains("lib/gcc/i686-apple-darwin")) { + return true; } return CompilerOptionsBuilder::excludeHeaderPath(path); } -void ClangCompilerOptionsBuilder::addPredefinedMacrosAndHeaderPathsOptions() +void ClangCompilerOptionsBuilder::addPredefinedHeaderPathsOptions() { - if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) - addPredefinedMacrosAndHeaderPathsOptionsForMsvc(); - else - addPredefinedMacrosAndHeaderPathsOptionsForNonMsvc(); -} - -void ClangCompilerOptionsBuilder::addPredefinedMacrosAndHeaderPathsOptionsForMsvc() -{ - add("-nostdinc"); add("-undef"); -} + add("-nostdinc"); + add("-nostdlibinc"); -void ClangCompilerOptionsBuilder::addPredefinedMacrosAndHeaderPathsOptionsForNonMsvc() -{ - static const QString resourceDir = clangIncludeDirectory(); - if (QTC_GUARD(!resourceDir.isEmpty())) { - add("-nostdlibinc"); - add("-I" + QDir::toNativeSeparators(resourceDir)); - add("-undef"); - } + if (m_projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) + add(includeDirOption() + clangIncludeDirectory()); } void ClangCompilerOptionsBuilder::addWrappedQtHeadersIncludePath() { - static const QString wrappedQtHeadersPath = creatorResourcePath() - + "/cplusplus/wrappedQtHeaders"; + static const QString resourcePath = creatorResourcePath(); + static QString wrappedQtHeadersPath = resourcePath + "/cplusplus/wrappedQtHeaders"; + QDir dir(wrappedQtHeadersPath); + QTC_ASSERT(QDir(wrappedQtHeadersPath).exists(), return;); if (m_projectPart.qtVersion != CppTools::ProjectPart::NoQt) { const QString wrappedQtCoreHeaderPath = wrappedQtHeadersPath + "/QtCore"; - add("-I" + QDir::toNativeSeparators(wrappedQtHeadersPath)); - add("-I" + QDir::toNativeSeparators(wrappedQtCoreHeaderPath)); + add(includeDirOption() + QDir::toNativeSeparators(wrappedQtHeadersPath)); + add(includeDirOption() + QDir::toNativeSeparators(wrappedQtCoreHeaderPath)); } } @@ -154,12 +141,26 @@ void ClangCompilerOptionsBuilder::addExtraOptions() QString ClangCompilerOptionsBuilder::clangIncludeDirectory() const { - QDir dir(creatorResourcePath() + "/clang/lib/clang/" + m_clangVersion + "/include"); - + QDir dir(creatorLibexecPath() + "/clang/lib/clang/" + m_clangVersion + "/include"); if (!dir.exists() || !QFileInfo(dir, "stdint.h").exists()) dir = QDir(m_clangResourceDirectory); + return QDir::toNativeSeparators(dir.canonicalPath()); +} - return dir.canonicalPath(); +void ClangCompilerOptionsBuilder::undefineClangVersionMacrosForMsvc() +{ + if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { + static QStringList macroNames { + "__clang__", + "__clang_major__", + "__clang_minor__", + "__clang_patchlevel__", + "__clang_version__" + }; + + foreach (const QString ¯oName, macroNames) + add(undefineOption() + macroName); + } } } // namespace CppTools diff --git a/src/plugins/cpptools/clangcompileroptionsbuilder.h b/src/plugins/cpptools/clangcompileroptionsbuilder.h index 4dadb6bed96..fbe2a5baad2 100644 --- a/src/plugins/cpptools/clangcompileroptionsbuilder.h +++ b/src/plugins/cpptools/clangcompileroptionsbuilder.h @@ -34,33 +34,24 @@ namespace CppTools { class CPPTOOLS_EXPORT ClangCompilerOptionsBuilder : public CompilerOptionsBuilder { public: - static QStringList build(const ProjectPart *projectPart, - ProjectFile::Kind fileKind, - PchUsage pchUsage, - const QString &clangVersion, - const QString &clangResourceDirectory); + QStringList build(ProjectFile::Kind fileKind, + PchUsage pchUsage); ClangCompilerOptionsBuilder(const ProjectPart &projectPart, - const QString &clangVersion, - const QString &clangResourceDirectory); + const QString &clangVersion = QString(), + const QString &clangResourceDirectory = QString()); + + virtual void addPredefinedHeaderPathsOptions(); + virtual void addExtraOptions(); bool excludeHeaderPath(const QString &path) const override; - void addPredefinedMacrosAndHeaderPathsOptions(); - - void addPredefinedMacrosAndHeaderPathsOptionsForMsvc(); - - void addPredefinedMacrosAndHeaderPathsOptionsForNonMsvc(); - - void addWrappedQtHeadersIncludePath(); - + virtual void addWrappedQtHeadersIncludePath(); void addProjectConfigFileInclude(); - void addExtraOptions(); + void undefineClangVersionMacrosForMsvc(); private: QString clangIncludeDirectory() const; - -private: QString m_clangVersion; QString m_clangResourceDirectory; }; diff --git a/src/plugins/cpptools/compileroptionsbuilder.cpp b/src/plugins/cpptools/compileroptionsbuilder.cpp index 079f76fc6aa..88a85e17cda 100644 --- a/src/plugins/cpptools/compileroptionsbuilder.cpp +++ b/src/plugins/cpptools/compileroptionsbuilder.cpp @@ -125,7 +125,7 @@ void CompilerOptionsBuilder::addPrecompiledHeaderOptions(PchUsage pchUsage) m_options.append(result); } -void CompilerOptionsBuilder::addToolchainAndProjectDefines() +void CompilerOptionsBuilder::addToolchainAndProjectMacros() { addMacros(m_projectPart.toolChainMacros); addMacros(m_projectPart.projectMacros); @@ -258,21 +258,6 @@ void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtension m_options.append(opts); } -void CompilerOptionsBuilder::addDefineToAvoidIncludingGccOrMinGwIntrinsics() -{ - // In gcc headers, lots of built-ins are referenced that clang does not understand. - // Therefore, prevent the inclusion of the header that references them. Of course, this - // will break if code actually requires stuff from there, but that should be the less common - // case. - - const Core::Id type = m_projectPart.toolchainType; - if (type == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID - || type == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID) { - addDefine({"_X86INTRIN_H_INCLUDED"}); - addDefine({"BOOST_UUID_NO_SIMD"}); - } -} - static QByteArray toMsCompatibilityVersionFormat(const QByteArray &mscFullVer) { return mscFullVer.left(2) diff --git a/src/plugins/cpptools/compileroptionsbuilder.h b/src/plugins/cpptools/compileroptionsbuilder.h index 48c23b3e912..8ca985dc28c 100644 --- a/src/plugins/cpptools/compileroptionsbuilder.h +++ b/src/plugins/cpptools/compileroptionsbuilder.h @@ -54,13 +54,11 @@ public: virtual void enableExceptions(); void addHeaderPathOptions(); void addPrecompiledHeaderOptions(PchUsage pchUsage); - void addToolchainAndProjectDefines(); + void addToolchainAndProjectMacros(); void addMacros(const ProjectExplorer::Macros ¯os); virtual void addLanguageOption(ProjectFile::Kind fileKind); virtual void addOptionsForLanguage(bool checkForBorlandExtensions = true); - void addDefineToAvoidIncludingGccOrMinGwIntrinsics(); - void addMsvcCompatibilityVersion(); void undefineCppLanguageFeatureMacrosForMsvc2015(); diff --git a/tests/unit/unittest/refactoringengine-test.cpp b/tests/unit/unittest/refactoringengine-test.cpp index 7367a33cdf2..a4f7d32d04a 100644 --- a/tests/unit/unittest/refactoringengine-test.cpp +++ b/tests/unit/unittest/refactoringengine-test.cpp @@ -129,12 +129,12 @@ void RefactoringEngine::SetUp() projectPart = CppTools::ProjectPart::Ptr(new CppTools::ProjectPart); projectPart->files.push_back(projectFile); - commandLine = Utils::SmallStringVector(ClangCompilerOptionsBuilder::build( - projectPart.data(), - projectFile.kind, - CppTools::CompilerOptionsBuilder::PchUsage::None, + ClangCompilerOptionsBuilder clangCOBuilder(*projectPart, CLANG_VERSION, - CLANG_RESOURCE_DIR)); + CLANG_RESOURCE_DIR); + commandLine = Utils::SmallStringVector(clangCOBuilder.build( + projectFile.kind, + CppTools::CompilerOptionsBuilder::PchUsage::None)); commandLine.push_back(qStringFilePath); }