feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ProjectExplorer: Simplify autoDetectToolChain parameters

Browse Source 
This leaves us larger freedom on what tool chain to construct
later in the process, hopefully allowing us to handle real GCC
and MinGW in one pass.

Change-Id: I6b0ca1af428129924cef0ae31d684e6bc2735213
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2023-09-28 15:16:50 +02:00
parent eb9d2d8f17
commit 58c8fe823c
2 changed files with 40 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
src/plugins/projectexplorer/gcctoolchain.cpp
View File

@@ -304,8 +304,24 @@ static FilePath gccInstallDir(const FilePath &compiler,
// GccToolChain // GccToolChain
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
static Id idForSubType(GccToolChain::SubType subType)
{
switch (subType) {
case GccToolChain::RealGcc:
return Constants::GCC_TOOLCHAIN_TYPEID;
case GccToolChain::Clang:
return Constants::CLANG_TOOLCHAIN_TYPEID;
case GccToolChain::MinGW:
return Constants::MINGW_TOOLCHAIN_TYPEID;
case GccToolChain::LinuxIcc:
return Constants::LINUXICC_TOOLCHAIN_TYPEID;
}
QTC_CHECK(false);
return Constants::GCC_TOOLCHAIN_TYPEID;
}
GccToolChain::GccToolChain(Utils::Id typeId, SubType subType) GccToolChain::GccToolChain(Utils::Id typeId, SubType subType)
: ToolChain(typeId), m_subType(subType) : ToolChain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
{ {
setTypeDisplayName(Tr::tr("GCC")); setTypeDisplayName(Tr::tr("GCC"));
setTargetAbiKey(targetAbiKeyC); setTargetAbiKey(targetAbiKeyC);
@@ -1357,14 +1373,14 @@ Toolchains GccToolChainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, Constants::LINUXICC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructLinuxIccToolchain); GccToolChain::LinuxIcc);
result += autoDetectToolchains(findCompilerCandidates(os, executables, "icc", true), result += autoDetectToolchains(findCompilerCandidates(os, executables, "icc", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, Constants::LINUXICC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructLinuxIccToolchain); GccToolChain::LinuxIcc);
// MinGW // MinGW
@@ -1376,13 +1392,13 @@ Toolchains GccToolChainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::MINGW_TOOLCHAIN_TYPEID, Constants::MINGW_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructMinGWToolchain, GccToolChain::MinGW,
tcChecker); tcChecker);
result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true), result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::MINGW_TOOLCHAIN_TYPEID, Constants::MINGW_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructMinGWToolchain, GccToolChain::MinGW,
tcChecker); tcChecker);
// Clang // Clang
@@ -1394,22 +1410,21 @@ Toolchains GccToolChainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, Constants::CLANG_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructClangToolchain)); GccToolChain::Clang));
tcs.append(autoDetectToolchains(findCompilerCandidates(os, executables, "clang", true), tcs.append(autoDetectToolchains(findCompilerCandidates(os, executables, "clang", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, Constants::CLANG_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructClangToolchain)); GccToolChain::Clang));
known.append(tcs); known.append(tcs);
const FilePath compilerPath = Core::ICore::clangExecutable(CLANG_BINDIR); const FilePath compilerPath = Core::ICore::clangExecutable(CLANG_BINDIR);
if (!compilerPath.isEmpty()) { if (!compilerPath.isEmpty()) {
tcs.append( tcs.append(autoDetectToolchains({compilerPath},
autoDetectToolchains({compilerPath}, Constants::C_LANGUAGE_ID,
Constants::C_LANGUAGE_ID, Constants::CLANG_TOOLCHAIN_TYPEID,
Constants::CLANG_TOOLCHAIN_TYPEID, known,
known, GccToolChain::Clang));
&constructClangToolchain));
} }
result += tcs; result += tcs;
@@ -1428,13 +1443,13 @@ Toolchains GccToolChainFactory::autoDetect(const ToolchainDetector &detector) co
Constants::CXX_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, Constants::GCC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructRealGccToolchain, GccToolChain::RealGcc,
tcChecker); tcChecker);
result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true), result += autoDetectToolchains(findCompilerCandidates(os, executables, "gcc", true),
Constants::C_LANGUAGE_ID, Constants::C_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, Constants::GCC_TOOLCHAIN_TYPEID,
detector.alreadyKnown, detector.alreadyKnown,
&constructRealGccToolchain, GccToolChain::RealGcc,
tcChecker); tcChecker);
} }
@@ -1456,7 +1471,7 @@ Toolchains GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) || if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
(tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc"))) { (tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc"))) {
result += autoDetectToolChain(tcd, &constructLinuxIccToolchain); result += autoDetectToolChain(tcd, GccToolChain::LinuxIcc);
} }
// MingW // MingW
@@ -1470,7 +1485,7 @@ Toolchains GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
|| (fileName.startsWith("c++") || fileName.endsWith("c++"))); || (fileName.startsWith("c++") || fileName.endsWith("c++")));
if (cCompiler || cxxCompiler) { if (cCompiler || cxxCompiler) {
result += autoDetectToolChain(tcd, &constructMinGWToolchain, [](const ToolChain *tc) { result += autoDetectToolChain(tcd, GccToolChain::MinGW, [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor; return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
}); });
} }
@@ -1486,7 +1501,7 @@ Toolchains GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
|| (fileName == "c++" && resolvedSymlinksFileName.contains("clang"))); || (fileName == "c++" && resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler) if (isCCompiler || isCxxCompiler)
result += autoDetectToolChain(tcd, &constructClangToolchain); result += autoDetectToolChain(tcd, GccToolChain::Clang);
// GCC // GCC
@@ -1501,7 +1516,7 @@ Toolchains GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
|| (fileName == "c++" && !resolvedSymlinksFileName.contains("clang"))); || (fileName == "c++" && !resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler) { if (isCCompiler || isCxxCompiler) {
result += autoDetectToolChain(tcd, &constructRealGccToolchain, [](const ToolChain *tc) { result += autoDetectToolChain(tcd, GccToolChain::RealGcc, [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor; return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor;
}); });
} }
@@ -1513,7 +1528,7 @@ Toolchains GccToolChainFactory::autoDetectToolchains(const FilePaths &compilerPa
const Id language, const Id language,
const Id requiredTypeId, const Id requiredTypeId,
const Toolchains &known, const Toolchains &known,
const ToolChainConstructor &constructor, const GccToolChain::SubType subType,
const ToolchainChecker &checker) const ToolchainChecker &checker)
{ {
Toolchains existingCandidates = filtered(known, Toolchains existingCandidates = filtered(known,
@@ -1555,7 +1570,7 @@ Toolchains GccToolChainFactory::autoDetectToolchains(const FilePaths &compilerPa
} }
if (!alreadyExists) { if (!alreadyExists) {
const QList<ToolChain *> newToolchains const QList<ToolChain *> newToolchains
= autoDetectToolChain({compilerPath, language}, constructor, checker); = autoDetectToolChain({compilerPath, language}, subType, checker);
result << newToolchains; result << newToolchains;
existingCandidates << newToolchains; existingCandidates << newToolchains;
} }
@@ -1565,7 +1580,7 @@ Toolchains GccToolChainFactory::autoDetectToolchains(const FilePaths &compilerPa
} }
Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd, Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
const ToolChainConstructor &constructor, const GccToolChain::SubType subType,
const ToolchainChecker &checker) const ToolchainChecker &checker)
{ {
Toolchains result; Toolchains result;
@@ -1586,9 +1601,7 @@ Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &
systemEnvironment, systemEnvironment,
macros); macros);
for (const Abi &abi : detectedAbis.supportedAbis) { for (const Abi &abi : detectedAbis.supportedAbis) {
std::unique_ptr<GccToolChain> tc(dynamic_cast<GccToolChain *>(constructor())); std::unique_ptr<GccToolChain> tc(new GccToolChain({}, subType));
if (!tc)
return result;
tc->setLanguage(tcd.language); tc->setLanguage(tcd.language);
tc->setDetection(ToolChain::AutoDetection); tc->setDetection(ToolChain::AutoDetection);

4
src/plugins/projectexplorer/gcctoolchain.h
View File

@@ -197,10 +197,10 @@ private:
const Utils::Id language, const Utils::Id language,
const Utils::Id requiredTypeId, const Utils::Id requiredTypeId,
const Toolchains &known, const Toolchains &known,
const ToolChainConstructor &constructor, const GccToolChain::SubType subType,
const ToolchainChecker &checker = {}); const ToolchainChecker &checker = {});
static Toolchains autoDetectToolChain(const ToolChainDescription &tcd, static Toolchains autoDetectToolChain(const ToolChainDescription &tcd,
const ToolChainConstructor &constructor, const GccToolChain::SubType subType,
const ToolchainChecker &checker = {}); const ToolchainChecker &checker = {});
const bool m_autoDetecting; const bool m_autoDetecting;