diff options
Diffstat (limited to 'src/plugins/cpptools/compileroptionsbuilder.cpp')
| -rw-r--r-- | src/plugins/cpptools/compileroptionsbuilder.cpp | 398 |
1 files changed, 189 insertions, 209 deletions
diff --git a/src/plugins/cpptools/compileroptionsbuilder.cpp b/src/plugins/cpptools/compileroptionsbuilder.cpp index bc1b8639a1..51f21cfb83 100644 --- a/src/plugins/cpptools/compileroptionsbuilder.cpp +++ b/src/plugins/cpptools/compileroptionsbuilder.cpp @@ -28,10 +28,12 @@ #include "cppmodelmanager.h" #include <coreplugin/icore.h> -#include <coreplugin/vcsmanager.h> -#include <projectexplorer/projectexplorerconstants.h> +#include <projectexplorer/headerpath.h> +#include <projectexplorer/language.h> #include <projectexplorer/project.h> +#include <projectexplorer/projectexplorerconstants.h> +#include <projectexplorer/projectmacro.h> #include <utils/fileutils.h> #include <utils/qtcassert.h> @@ -41,22 +43,53 @@ namespace CppTools { +static const char defineOption[] = "-D"; +static const char undefineOption[] = "-U"; + +static const char includeUserPathOption[] = "-I"; +static const char includeSystemPathOption[] = "-isystem"; + +static const char includeFileOption[] = "-include"; + +static QByteArray macroOption(const ProjectExplorer::Macro ¯o) +{ + switch (macro.type) { + case ProjectExplorer::MacroType::Define: return defineOption; + case ProjectExplorer::MacroType::Undefine: return undefineOption; + default: return QByteArray(); + } +} + +static QByteArray toDefineOption(const ProjectExplorer::Macro ¯o) +{ + return macro.toKeyValue(macroOption(macro)); +} + +static QString defineDirectiveToDefineOption(const ProjectExplorer::Macro ¯o) +{ + const QByteArray option = toDefineOption(macro); + return QString::fromUtf8(option); +} + CompilerOptionsBuilder::CompilerOptionsBuilder(const ProjectPart &projectPart, UseSystemHeader useSystemHeader, - SkipBuiltIn skipBuiltInHeaderPathsAndDefines, - SkipLanguageDefines skipLanguageDefines, - QString clangVersion, - QString clangResourceDirectory) + 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) , m_clangResourceDirectory(clangResourceDirectory) - , m_useSystemHeader(useSystemHeader) - , m_skipBuiltInHeaderPathsAndDefines(skipBuiltInHeaderPathsAndDefines) - , m_skipLanguageDefines(skipLanguageDefines) { } -QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, PchUsage pchUsage) +QStringList CompilerOptionsBuilder::build(ProjectFile::Kind fileKind, + UsePrecompiledHeaders usePrecompiledHeaders) { m_options.clear(); @@ -84,10 +117,9 @@ QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, undefineClangVersionMacrosForMsvc(); undefineCppLanguageFeatureMacrosForMsvc2015(); addDefineFunctionMacrosMsvc(); - addBoostWorkaroundMacros(); addToolchainFlags(); - addPrecompiledHeaderOptions(pchUsage); + addPrecompiledHeaderOptions(usePrecompiledHeaders); addHeaderPathOptions(); addProjectConfigFileInclude(); @@ -102,7 +134,7 @@ QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind, static QStringList createLanguageOptionGcc(ProjectFile::Kind fileKind, bool objcExt) { - QStringList opts; + QStringList options; switch (fileKind) { case ProjectFile::Unclassified: @@ -110,80 +142,67 @@ static QStringList createLanguageOptionGcc(ProjectFile::Kind fileKind, bool objc break; case ProjectFile::CHeader: if (objcExt) - opts += QLatin1String("objective-c-header"); + options += "objective-c-header"; else - opts += QLatin1String("c-header"); + options += "c-header"; break; - case ProjectFile::CXXHeader: default: if (!objcExt) { - opts += QLatin1String("c++-header"); + options += "c++-header"; break; } Q_FALLTHROUGH(); case ProjectFile::ObjCHeader: case ProjectFile::ObjCXXHeader: - opts += QLatin1String("objective-c++-header"); + options += "objective-c++-header"; break; case ProjectFile::CSource: if (!objcExt) { - opts += QLatin1String("c"); + options += "c"; break; } Q_FALLTHROUGH(); case ProjectFile::ObjCSource: - opts += QLatin1String("objective-c"); + options += "objective-c"; break; - case ProjectFile::CXXSource: if (!objcExt) { - opts += QLatin1String("c++"); + options += "c++"; break; } Q_FALLTHROUGH(); case ProjectFile::ObjCXXSource: - opts += QLatin1String("objective-c++"); + options += "objective-c++"; break; - case ProjectFile::OpenCLSource: - opts += QLatin1String("cl"); + options += "cl"; break; case ProjectFile::CudaSource: - opts += QLatin1String("cuda"); + options += "cuda"; break; } - if (!opts.isEmpty()) - opts.prepend(QLatin1String("-x")); + if (!options.isEmpty()) + options.prepend("-x"); - return opts; -} - -QStringList CompilerOptionsBuilder::options() const -{ - return m_options; -} - -void CompilerOptionsBuilder::add(const QString &option) -{ - m_options.append(option); + return options; } void CompilerOptionsBuilder::addWordWidth() { const QString argument = m_projectPart.toolChainWordWidth == ProjectPart::WordWidth64Bit - ? QLatin1String("-m64") - : QLatin1String("-m32"); + ? QLatin1String("-m64") + : QLatin1String("-m32"); add(argument); } void CompilerOptionsBuilder::addTargetTriple() { if (!m_projectPart.toolChainTargetTriple.isEmpty()) { - m_options.append(QLatin1String("-target")); - m_options.append(m_projectPart.toolChainTargetTriple); + add("-target"); + add(m_projectPart.toolChainTargetTriple); } } @@ -198,8 +217,8 @@ void CompilerOptionsBuilder::addExtraCodeModelFlags() void CompilerOptionsBuilder::enableExceptions() { if (m_projectPart.languageVersion > ProjectExplorer::LanguageVersion::LatestC) - add(QLatin1String("-fcxx-exceptions")); - add(QLatin1String("-fexceptions")); + add("-fcxx-exceptions"); + add("-fexceptions"); } static QString creatorResourcePath() @@ -217,6 +236,8 @@ static QString clangIncludeDirectory(const QString &clangVersion, #ifndef UNIT_TESTS return Core::ICore::clangIncludeDirectory(clangVersion, clangResourceDirectory); #else + Q_UNUSED(clangVersion); + Q_UNUSED(clangResourceDirectory); return QDir::toNativeSeparators(QString::fromUtf8(CLANG_RESOURCE_DIR "")); #endif } @@ -242,19 +263,19 @@ static QStringList insertResourceDirectory(const QStringList &options, } for (const QString &option : options) { - if (option == "-isystem") + if (option == includeSystemPathOption) continue; if (includeRegExp.match(option).hasMatch()) { - optionsBeforeResourceDirectory.push_back("-isystem"); + optionsBeforeResourceDirectory.push_back(includeSystemPathOption); optionsBeforeResourceDirectory.push_back(option); } else { - optionsAfterResourceDirectory.push_back("-isystem"); + optionsAfterResourceDirectory.push_back(includeSystemPathOption); optionsAfterResourceDirectory.push_back(option); } } - optionsBeforeResourceDirectory.push_back("-isystem"); + optionsBeforeResourceDirectory.push_back(includeSystemPathOption); optionsBeforeResourceDirectory.push_back(resourceDir); return optionsBeforeResourceDirectory + optionsAfterResourceDirectory; @@ -262,7 +283,7 @@ static QStringList insertResourceDirectory(const QStringList &options, void CompilerOptionsBuilder::insertWrappedQtHeaders() { - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::Yes) + if (m_useTweakedHeaderPaths == UseTweakedHeaderPaths::No) return; QStringList wrappedQtHeaders; @@ -275,6 +296,17 @@ void CompilerOptionsBuilder::insertWrappedQtHeaders() m_options = m_options.mid(0, index) + wrappedQtHeaders + m_options.mid(index); } +static bool excludeHeaderPath(const QString &headerPath) +{ + // Always exclude clang system includes (including intrinsics) which do not come with libclang + // that Qt Creator uses for code model. + // For example GCC on macOS uses system clang include path which makes clang code model + // include incorrect system headers. + static const QRegularExpression clangIncludeDir( + R"(\A.*[\/\\]lib\d*[\/\\]clang[\/\\]\d+\.\d+(\.\d+)?[\/\\]include\z)"); + return clangIncludeDir.match(headerPath).hasMatch(); +} + void CompilerOptionsBuilder::addHeaderPathOptions() { using ProjectExplorer::HeaderPathType; @@ -295,20 +327,18 @@ void CompilerOptionsBuilder::addHeaderPathOptions() includes.append("-F"); includes.append(QDir::toNativeSeparators(headerPath.path)); break; - default: // This shouldn't happen, but let's be nice..: - // intentional fall-through: case HeaderPathType::User: includes.append(includeDirOptionForPath(headerPath.path)); includes.append(QDir::toNativeSeparators(headerPath.path)); break; case HeaderPathType::BuiltIn: - builtInIncludes.append("-isystem"); + builtInIncludes.append(includeSystemPathOption); builtInIncludes.append(QDir::toNativeSeparators(headerPath.path)); break; case HeaderPathType::System: - systemIncludes.append(m_useSystemHeader == UseSystemHeader::No - ? QLatin1String("-I") - : QLatin1String("-isystem")); + systemIncludes.append(m_useSystemHeader == UseSystemHeader::Yes + ? QLatin1String(includeSystemPathOption) + : QLatin1String(includeUserPathOption)); systemIncludes.append(QDir::toNativeSeparators(headerPath.path)); break; } @@ -317,7 +347,7 @@ void CompilerOptionsBuilder::addHeaderPathOptions() m_options.append(includes); m_options.append(systemIncludes); - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::Yes) + if (m_useTweakedHeaderPaths == UseTweakedHeaderPaths::No) return; // Exclude all built-in includes except Clang resource directory. @@ -339,45 +369,44 @@ void CompilerOptionsBuilder::addHeaderPathOptions() m_options.append(builtInIncludes); } -void CompilerOptionsBuilder::addPrecompiledHeaderOptions(PchUsage pchUsage) +void CompilerOptionsBuilder::addPrecompiledHeaderOptions(UsePrecompiledHeaders usePrecompiledHeaders) { - if (pchUsage == PchUsage::None) + if (usePrecompiledHeaders == UsePrecompiledHeaders::No) return; - QStringList result; + QStringList options; - const QString includeOptionString = includeOption(); - foreach (const QString &pchFile, m_projectPart.precompiledHeaders) { + for (const QString &pchFile : m_projectPart.precompiledHeaders) { if (QFile::exists(pchFile)) { - result += includeOptionString; - result += QDir::toNativeSeparators(pchFile); + options += includeFileOption; + options += QDir::toNativeSeparators(pchFile); } } - m_options.append(result); + m_options.append(options); } void CompilerOptionsBuilder::addToolchainAndProjectMacros() { - if (m_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::No) + if (m_useToolchainMacros == UseToolchainMacros::Yes) addMacros(m_projectPart.toolChainMacros); addMacros(m_projectPart.projectMacros); } void CompilerOptionsBuilder::addMacros(const ProjectExplorer::Macros ¯os) { - QStringList result; + QStringList options; for (const ProjectExplorer::Macro ¯o : macros) { if (excludeDefineDirective(macro)) continue; const QString defineOption = defineDirectiveToDefineOption(macro); - if (!result.contains(defineOption)) - result.append(defineOption); + if (!options.contains(defineOption)) + options.append(defineOption); } - m_options.append(result); + m_options.append(options); } void CompilerOptionsBuilder::updateLanguageOption(ProjectFile::Kind fileKind) @@ -390,11 +419,10 @@ void CompilerOptionsBuilder::updateLanguageOption(ProjectFile::Kind fileKind) QTC_ASSERT(options.size() == 2, return;); int langOptIndex = m_options.indexOf("-x"); - if (langOptIndex == -1) { + if (langOptIndex == -1) m_options.append(options); - } else { + else m_options[langOptIndex + 1] = options[1]; - } } void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtensions) @@ -402,54 +430,54 @@ void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtension using ProjectExplorer::LanguageExtension; using ProjectExplorer::LanguageVersion; - QStringList opts; + QStringList options; const ProjectExplorer::LanguageExtensions languageExtensions = m_projectPart.languageExtensions; const bool gnuExtensions = languageExtensions & LanguageExtension::Gnu; switch (m_projectPart.languageVersion) { case LanguageVersion::C89: - opts << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89")); + options << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89")); break; case LanguageVersion::C99: - opts << (gnuExtensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99")); + options << (gnuExtensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99")); break; case LanguageVersion::C11: - opts << (gnuExtensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11")); + options << (gnuExtensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11")); break; case LanguageVersion::C18: // Clang 6, 7 and current trunk do not accept "gnu18"/"c18", so use the "*17" variants. - opts << (gnuExtensions ? QLatin1String("-std=gnu17") : QLatin1String("-std=c17")); + options << (gnuExtensions ? QLatin1String("-std=gnu17") : QLatin1String("-std=c17")); break; case LanguageVersion::CXX11: - opts << (gnuExtensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11")); + options << (gnuExtensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11")); break; case LanguageVersion::CXX98: - opts << (gnuExtensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98")); + options << (gnuExtensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98")); break; case LanguageVersion::CXX03: - opts << (gnuExtensions ? QLatin1String("-std=gnu++03") : QLatin1String("-std=c++03")); + options << (gnuExtensions ? QLatin1String("-std=gnu++03") : QLatin1String("-std=c++03")); break; case LanguageVersion::CXX14: - opts << (gnuExtensions ? QLatin1String("-std=gnu++14") : QLatin1String("-std=c++14")); + options << (gnuExtensions ? QLatin1String("-std=gnu++14") : QLatin1String("-std=c++14")); break; case LanguageVersion::CXX17: - opts << (gnuExtensions ? QLatin1String("-std=gnu++17") : QLatin1String("-std=c++17")); + options << (gnuExtensions ? QLatin1String("-std=gnu++17") : QLatin1String("-std=c++17")); break; case LanguageVersion::CXX2a: - opts << (gnuExtensions ? QLatin1String("-std=gnu++2a") : QLatin1String("-std=c++2a")); + options << (gnuExtensions ? QLatin1String("-std=gnu++2a") : QLatin1String("-std=c++2a")); break; } if (languageExtensions & LanguageExtension::Microsoft) - opts << QLatin1String("-fms-extensions"); + options << "-fms-extensions"; if (languageExtensions & LanguageExtension::OpenMP) - opts << QLatin1String("-fopenmp"); + options << "-fopenmp"; if (checkForBorlandExtensions && (languageExtensions & LanguageExtension::Borland)) - opts << QLatin1String("-fborland-extensions"); + options << "-fborland-extensions"; - m_options.append(opts); + m_options.append(options); } static QByteArray toMsCompatibilityVersionFormat(const QByteArray &mscFullVer) @@ -477,11 +505,8 @@ void CompilerOptionsBuilder::addMsvcCompatibilityVersion() + m_projectPart.projectMacros; const QByteArray msvcVersion = msCompatibilityVersionFromDefines(macros); - if (!msvcVersion.isEmpty()) { - const QString option = QLatin1String("-fms-compatibility-version=") - + QLatin1String(msvcVersion); - m_options.append(option); - } + if (!msvcVersion.isEmpty()) + add(QLatin1String("-fms-compatibility-version=") + msvcVersion); } } @@ -492,54 +517,54 @@ static QStringList languageFeatureMacros() // * Use latest -fms-compatibility-version and -std possible. // * Compatibility version 19 vs 1910 did not matter. // $ clang++ -fms-compatibility-version=19 -std=c++1z -dM -E D:\empty.cpp | grep __cpp_ - static QStringList macros{ - QLatin1String("__cpp_aggregate_bases"), - QLatin1String("__cpp_aggregate_nsdmi"), - QLatin1String("__cpp_alias_templates"), - QLatin1String("__cpp_aligned_new"), - QLatin1String("__cpp_attributes"), - QLatin1String("__cpp_binary_literals"), - QLatin1String("__cpp_capture_star_this"), - QLatin1String("__cpp_constexpr"), - QLatin1String("__cpp_decltype"), - QLatin1String("__cpp_decltype_auto"), - QLatin1String("__cpp_deduction_guides"), - QLatin1String("__cpp_delegating_constructors"), - QLatin1String("__cpp_digit_separators"), - QLatin1String("__cpp_enumerator_attributes"), - QLatin1String("__cpp_exceptions"), - QLatin1String("__cpp_fold_expressions"), - QLatin1String("__cpp_generic_lambdas"), - QLatin1String("__cpp_guaranteed_copy_elision"), - QLatin1String("__cpp_hex_float"), - QLatin1String("__cpp_if_constexpr"), - QLatin1String("__cpp_inheriting_constructors"), - QLatin1String("__cpp_init_captures"), - QLatin1String("__cpp_initializer_lists"), - QLatin1String("__cpp_inline_variables"), - QLatin1String("__cpp_lambdas"), - QLatin1String("__cpp_namespace_attributes"), - QLatin1String("__cpp_nested_namespace_definitions"), - QLatin1String("__cpp_noexcept_function_type"), - QLatin1String("__cpp_nontype_template_args"), - QLatin1String("__cpp_nontype_template_parameter_auto"), - QLatin1String("__cpp_nsdmi"), - QLatin1String("__cpp_range_based_for"), - QLatin1String("__cpp_raw_strings"), - QLatin1String("__cpp_ref_qualifiers"), - QLatin1String("__cpp_return_type_deduction"), - QLatin1String("__cpp_rtti"), - QLatin1String("__cpp_rvalue_references"), - QLatin1String("__cpp_static_assert"), - QLatin1String("__cpp_structured_bindings"), - QLatin1String("__cpp_template_auto"), - QLatin1String("__cpp_threadsafe_static_init"), - QLatin1String("__cpp_unicode_characters"), - QLatin1String("__cpp_unicode_literals"), - QLatin1String("__cpp_user_defined_literals"), - QLatin1String("__cpp_variable_templates"), - QLatin1String("__cpp_variadic_templates"), - QLatin1String("__cpp_variadic_using"), + static const QStringList macros{ + "__cpp_aggregate_bases", + "__cpp_aggregate_nsdmi", + "__cpp_alias_templates", + "__cpp_aligned_new", + "__cpp_attributes", + "__cpp_binary_literals", + "__cpp_capture_star_this", + "__cpp_constexpr", + "__cpp_decltype", + "__cpp_decltype_auto", + "__cpp_deduction_guides", + "__cpp_delegating_constructors", + "__cpp_digit_separators", + "__cpp_enumerator_attributes", + "__cpp_exceptions", + "__cpp_fold_expressions", + "__cpp_generic_lambdas", + "__cpp_guaranteed_copy_elision", + "__cpp_hex_float", + "__cpp_if_constexpr", + "__cpp_inheriting_constructors", + "__cpp_init_captures", + "__cpp_initializer_lists", + "__cpp_inline_variables", + "__cpp_lambdas", + "__cpp_namespace_attributes", + "__cpp_nested_namespace_definitions", + "__cpp_noexcept_function_type", + "__cpp_nontype_template_args", + "__cpp_nontype_template_parameter_auto", + "__cpp_nsdmi", + "__cpp_range_based_for", + "__cpp_raw_strings", + "__cpp_ref_qualifiers", + "__cpp_return_type_deduction", + "__cpp_rtti", + "__cpp_rvalue_references", + "__cpp_static_assert", + "__cpp_structured_bindings", + "__cpp_template_auto", + "__cpp_threadsafe_static_init", + "__cpp_unicode_characters", + "__cpp_unicode_literals", + "__cpp_user_defined_literals", + "__cpp_variable_templates", + "__cpp_variadic_templates", + "__cpp_variadic_using", }; return macros; @@ -551,22 +576,18 @@ void CompilerOptionsBuilder::undefineCppLanguageFeatureMacrosForMsvc2015() && m_projectPart.isMsvc2015Toolchain) { // Undefine the language feature macros that are pre-defined in clang-cl, // but not in MSVC's cl.exe. - foreach (const QString ¯oName, languageFeatureMacros()) - m_options.append(undefineOption() + macroName); + const QStringList macroNames = languageFeatureMacros(); + for (const QString ¯oName : macroNames) + add(undefineOption + macroName); } } void CompilerOptionsBuilder::addDefineFunctionMacrosMsvc() { - if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) - addMacros({{"__FUNCSIG__", "\"\""}, {"__FUNCTION__", "\"\""}, {"__FUNCDNAME__", "\"\""}}); -} - -void CompilerOptionsBuilder::addBoostWorkaroundMacros() -{ - if (m_projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID - && m_projectPart.toolchainType != ProjectExplorer::Constants::CLANG_CL_TOOLCHAIN_TYPEID) { - addMacros({{"BOOST_TYPE_INDEX_CTTI_USER_DEFINED_PARSING", "(39, 1, true, \"T = \")"}}); + if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { + addMacros({{"__FUNCSIG__", "\"\""}, + {"__FUNCTION__", "\"\""}, + {"__FUNCDNAME__", "\"\""}}); } } @@ -574,46 +595,10 @@ QString CompilerOptionsBuilder::includeDirOptionForPath(const QString &path) con { if (m_useSystemHeader == UseSystemHeader::No || path.startsWith(m_projectPart.project->rootProjectDirectory().toString())) { - return QString("-I"); - } else { - return QString("-isystem"); + return QLatin1String(includeUserPathOption); } -} - -QByteArray CompilerOptionsBuilder::macroOption(const ProjectExplorer::Macro ¯o) const -{ - switch (macro.type) { - case ProjectExplorer::MacroType::Define: return defineOption().toUtf8(); - case ProjectExplorer::MacroType::Undefine: return undefineOption().toUtf8(); - default: return QByteArray(); - } -} - -QByteArray CompilerOptionsBuilder::toDefineOption(const ProjectExplorer::Macro ¯o) const -{ - return macro.toKeyValue(macroOption(macro)); -} - -QString CompilerOptionsBuilder::defineDirectiveToDefineOption(const ProjectExplorer::Macro ¯o) const -{ - const QByteArray option = toDefineOption(macro); - return QString::fromUtf8(option); -} - -QString CompilerOptionsBuilder::defineOption() const -{ - return QLatin1String("-D"); -} - -QString CompilerOptionsBuilder::undefineOption() const -{ - return QLatin1String("-U"); -} - -QString CompilerOptionsBuilder::includeOption() const -{ - return QLatin1String("-include"); + return QLatin1String(includeSystemPathOption); } bool CompilerOptionsBuilder::excludeDefineDirective(const ProjectExplorer::Macro ¯o) const @@ -626,7 +611,7 @@ bool CompilerOptionsBuilder::excludeDefineDirective(const ProjectExplorer::Macro "_MSVC_LANG", "_MSC_FULL_VER", "_MSC_VER"}; - if (m_skipLanguageDefines == SkipLanguageDefines::Yes + if (m_useLanguageDefines == UseLanguageDefines::No && std::find(languageDefines.begin(), languageDefines.end(), macro.key) != languageDefines.end()) { @@ -658,24 +643,13 @@ bool CompilerOptionsBuilder::excludeDefineDirective(const ProjectExplorer::Macro return false; } -bool CompilerOptionsBuilder::excludeHeaderPath(const QString &headerPath) const -{ - // Always exclude clang system includes (including intrinsics) which do not come with libclang - // that Qt Creator uses for code model. - // For example GCC on macOS uses system clang include path which makes clang code model - // include incorrect system headers. - static QRegularExpression clangIncludeDir( - QLatin1String("\\A.*[\\/\\\\]lib\\d*[\\/\\\\]clang[\\/\\\\]\\d+\\.\\d+(\\.\\d+)?[\\/\\\\]include\\z")); - return clangIncludeDir.match(headerPath).hasMatch(); -} - -void CompilerOptionsBuilder::addWrappedQtHeadersIncludePath(QStringList &list) +void CompilerOptionsBuilder::addWrappedQtHeadersIncludePath(QStringList &list) const { static const QString resourcePath = creatorResourcePath(); static QString wrappedQtHeadersPath = resourcePath + "/cplusplus/wrappedQtHeaders"; QTC_ASSERT(QDir(wrappedQtHeadersPath).exists(), return;); - if (m_projectPart.qtVersion != CppTools::ProjectPart::NoQt) { + if (m_projectPart.qtVersion != ProjectPart::NoQt) { const QString wrappedQtCoreHeaderPath = wrappedQtHeadersPath + "/QtCore"; list.append(includeDirOptionForPath(wrappedQtHeadersPath)); list.append(QDir::toNativeSeparators(wrappedQtHeadersPath)); @@ -689,7 +663,7 @@ 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_skipBuiltInHeaderPathsAndDefines == SkipBuiltIn::No) + if (m_useToolchainMacros == UseToolchainMacros::Yes) add("-undef"); else add("-fPIC"); @@ -699,7 +673,7 @@ void CompilerOptionsBuilder::addToolchainFlags() void CompilerOptionsBuilder::addProjectConfigFileInclude() { if (!m_projectPart.projectConfigFile.isEmpty()) { - add("-include"); + add(includeFileOption); add(QDir::toNativeSeparators(m_projectPart.projectConfigFile)); } } @@ -707,7 +681,7 @@ void CompilerOptionsBuilder::addProjectConfigFileInclude() void CompilerOptionsBuilder::undefineClangVersionMacrosForMsvc() { if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { - static QStringList macroNames { + static const QStringList macroNames { "__clang__", "__clang_major__", "__clang_minor__", @@ -715,9 +689,15 @@ void CompilerOptionsBuilder::undefineClangVersionMacrosForMsvc() "__clang_version__" }; - foreach (const QString ¯oName, macroNames) - add(undefineOption() + macroName); + for (const QString ¯oName : macroNames) + add(undefineOption + macroName); } } +UseToolchainMacros CompilerOptionsBuilder::useToolChainMacros() +{ + return qEnvironmentVariableIntValue("QTC_CLANG_USE_TOOLCHAIN_MACROS") ? UseToolchainMacros::Yes + : UseToolchainMacros::No; +} + } // namespace CppTools |