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

ProjectExplorer: Rename Tool{C,c}hainKitAspect

Browse Source 
Change-Id: I74460b6402ab00f972c208023f03fac617982a11
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
This commit is contained in:
hjk
2023-11-24 17:55:50 +01:00
parent ba249a3514
commit 3bbda8f9da
51 changed files with 167 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/plugins/android/androidconfigurations.cpp
View File

@@ -1387,9 +1387,9 @@ void AndroidConfigurations::updateAutomaticKitList()
if (qt != QtKitAspect::qtVersion(b)) if (qt != QtKitAspect::qtVersion(b))
return false; return false;
return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID], return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
ToolChainKitAspect::cxxToolChain(b)) ToolchainKitAspect::cxxToolChain(b))
&& matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID], && matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
ToolChainKitAspect::cToolChain(b)); ToolchainKitAspect::cToolChain(b));
}); });
const auto initializeKit = [allLanguages, tc, qt](Kit *k) { const auto initializeKit = [allLanguages, tc, qt](Kit *k) {
@@ -1397,7 +1397,7 @@ void AndroidConfigurations::updateAutomaticKitList()
k->setAutoDetectionSource("AndroidConfiguration"); k->setAutoDetectionSource("AndroidConfiguration");
DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE); DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE);
for (Toolchain *tc : allLanguages) for (Toolchain *tc : allLanguages)
ToolChainKitAspect::setToolChain(k, tc); ToolchainKitAspect::setToolChain(k, tc);
QtKitAspect::setQtVersion(k, qt); QtKitAspect::setQtVersion(k, qt);
QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis(); QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis();
Debugger::DebuggerKitAspect::setDebugger(k, findOrRegisterDebugger(tc, abis)); Debugger::DebuggerKitAspect::setDebugger(k, findOrRegisterDebugger(tc, abis));

2
src/plugins/android/androidmanager.cpp
View File

@@ -183,7 +183,7 @@ QJsonObject deploymentSettings(const Target *target)
if (!qt) if (!qt)
return {}; return {};
auto tc = ToolChainKitAspect::cxxToolChain(target->kit()); auto tc = ToolchainKitAspect::cxxToolChain(target->kit());
if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_TYPEID) if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_TYPEID)
return {}; return {};
QJsonObject settings; QJsonObject settings;

2
src/plugins/android/androidpackageinstallationstep.cpp
View File

@@ -73,7 +73,7 @@ bool AndroidPackageInstallationStep::init()
return false; return false;
} }
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit()); Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
QTC_ASSERT(tc, reportWarningOrError(Tr::tr("\"%1\" step has an invalid C++ toolchain.") QTC_ASSERT(tc, reportWarningOrError(Tr::tr("\"%1\" step has an invalid C++ toolchain.")
.arg(displayName()), Task::TaskType::Error); .arg(displayName()), Task::TaskType::Error);
return false); return false);

2
src/plugins/autotest/autotestunittests.cpp
View File

@@ -59,7 +59,7 @@ void AutoTestUnitTests::initTestCase()
m_isQt4 = qtVersion->qtVersionString().startsWith('4'); m_isQt4 = qtVersion->qtVersionString().startsWith('4');
else else
QSKIP("Could not figure out which Qt version is used for default kit."); QSKIP("Could not figure out which Qt version is used for default kit.");
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit); const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
if (!toolchain) if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain."); QSKIP("This test requires that there is a kit with a toolchain.");

2
src/plugins/autotest/loadprojectscenario.cpp
View File

@@ -56,7 +56,7 @@ bool LoadProjectScenario::init()
return false; return false;
} }
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit); const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
if (!toolchain) { if (!toolchain) {
qWarning() << "This test requires that there is a kit with a toolchain."; qWarning() << "This test requires that there is a kit with a toolchain.";
return false; return false;

2
src/plugins/clangtools/clangtool.cpp
View File

@@ -1034,7 +1034,7 @@ static bool canAnalyzeProject(Project *project)
|| project->projectLanguages().contains(cxx); || project->projectLanguages().contains(cxx);
return projectSupportsLanguage return projectSupportsLanguage
&& CppModelManager::projectInfo(project) && CppModelManager::projectInfo(project)
&& ToolChainKitAspect::cxxToolChain(target->kit()); && ToolchainKitAspect::cxxToolChain(target->kit());
} }
return false; return false;
} }

2
src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
View File

@@ -148,7 +148,7 @@ static QList<Target *> validTargets(Project *project)
return false; return false;
} }
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(kit); const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(kit);
QTC_ASSERT(toolchain, return false); QTC_ASSERT(toolchain, return false);
if (Core::ICore::clangExecutable(CLANG_BINDIR).isEmpty()) { if (Core::ICore::clangExecutable(CLANG_BINDIR).isEmpty()) {

4
src/plugins/clangtools/clangtoolsunittests.cpp
View File

@@ -50,7 +50,7 @@ void ClangToolsUnitTests::initTestCase()
if (!m_kit) if (!m_kit)
QSKIP("This test requires at least one valid kit with a valid Qt"); QSKIP("This test requires at least one valid kit with a valid Qt");
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit); const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
if (!toolchain) if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain."); QSKIP("This test requires that there is a kit with a toolchain.");
@@ -87,7 +87,7 @@ void ClangToolsUnitTests::testProject()
QFETCH(int, expectedDiagCountClazy); QFETCH(int, expectedDiagCountClazy);
QFETCH(ClangDiagnosticConfig, diagnosticConfig); QFETCH(ClangDiagnosticConfig, diagnosticConfig);
if (projectFilePath.contains("mingw")) { if (projectFilePath.contains("mingw")) {
const auto toolchain = ToolChainKitAspect::cxxToolChain(m_kit); const auto toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) if (toolchain->typeId() != ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID)
QSKIP("This test is mingw specific, does not run for other toolchains"); QSKIP("This test is mingw specific, does not run for other toolchains");
} }

4
src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
View File

@@ -1091,7 +1091,7 @@ static bool isQnx(const Kit *k)
static bool isWindowsARM64(const Kit *k) static bool isWindowsARM64(const Kit *k)
{ {
Toolchain *toolchain = ToolChainKitAspect::cxxToolChain(k); Toolchain *toolchain = ToolchainKitAspect::cxxToolChain(k);
if (!toolchain) if (!toolchain)
return false; return false;
const Abi targetAbi = toolchain->targetAbi(); const Abi targetAbi = toolchain->targetAbi();
@@ -1124,7 +1124,7 @@ static CommandLine defaultInitialCMakeCommand(const Kit *k, const QString &build
const QString sysRoot = SysRootKitAspect::sysRoot(k).path(); const QString sysRoot = SysRootKitAspect::sysRoot(k).path();
if (!sysRoot.isEmpty()) { if (!sysRoot.isEmpty()) {
cmd.addArg("-DCMAKE_SYSROOT:PATH=" + sysRoot); cmd.addArg("-DCMAKE_SYSROOT:PATH=" + sysRoot);
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) { if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
const QString targetTriple = tc->originalTargetTriple(); const QString targetTriple = tc->originalTargetTriple();
cmd.addArg("-DCMAKE_C_COMPILER_TARGET:STRING=" + targetTriple); cmd.addArg("-DCMAKE_C_COMPILER_TARGET:STRING=" + targetTriple);
cmd.addArg("-DCMAKE_CXX_COMPILER_TARGET:STRING=" + targetTriple); cmd.addArg("-DCMAKE_CXX_COMPILER_TARGET:STRING=" + targetTriple);

2
src/plugins/cmakeprojectmanager/cmakebuildstep.cpp
View File

@@ -335,7 +335,7 @@ void CMakeBuildStep::setupOutputFormatter(Utils::OutputFormatter *formatter)
formatter->addLineParser(progressParser); formatter->addLineParser(progressParser);
cmakeParser->setSourceDirectory(project()->projectDirectory()); cmakeParser->setSourceDirectory(project()->projectDirectory());
formatter->addLineParsers({cmakeParser, new GnuMakeParser}); formatter->addLineParsers({cmakeParser, new GnuMakeParser});
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit()); Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
OutputTaskParser *xcodeBuildParser = nullptr; OutputTaskParser *xcodeBuildParser = nullptr;
if (tc && tc->targetAbi().os() == Abi::DarwinOS) { if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
xcodeBuildParser = new XcodebuildParser; xcodeBuildParser = new XcodebuildParser;

6
src/plugins/cmakeprojectmanager/cmakekitaspect.cpp
View File

@@ -681,7 +681,7 @@ QVariant CMakeGeneratorKitAspectFactory::defaultValue(const Kit *k) const
if (tool->filePath().osType() == OsTypeWindows) { if (tool->filePath().osType() == OsTypeWindows) {
// *sigh* Windows with its zoo of incompatible stuff again... // *sigh* Windows with its zoo of incompatible stuff again...
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k); Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) { if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
it = std::find_if(known.constBegin(), it = std::find_if(known.constBegin(),
known.constEnd(), known.constEnd(),
@@ -1135,8 +1135,8 @@ Tasks CMakeConfigurationKitAspectFactory::validate(const Kit *k) const
return Tasks(); return Tasks();
const QtSupport::QtVersion *const version = QtSupport::QtKitAspect::qtVersion(k); const QtSupport::QtVersion *const version = QtSupport::QtKitAspect::qtVersion(k);
const Toolchain *const tcC = ToolChainKitAspect::cToolChain(k); const Toolchain *const tcC = ToolchainKitAspect::cToolChain(k);
const Toolchain *const tcCxx = ToolChainKitAspect::cxxToolChain(k); const Toolchain *const tcCxx = ToolchainKitAspect::cxxToolChain(k);
const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k); const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
const bool isQt4 = version && version->qtVersion() < QVersionNumber(5, 0, 0); const bool isQt4 = version && version->qtVersion() < QVersionNumber(5, 0, 0);

2
src/plugins/cmakeprojectmanager/cmakeproject.cpp
View File

@@ -58,7 +58,7 @@ Tasks CMakeProject::projectIssues(const Kit *k) const
if (!CMakeKitAspect::cmakeTool(k)) if (!CMakeKitAspect::cmakeTool(k))
result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No cmake tool set."))); result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No cmake tool set.")));
if (ToolChainKitAspect::toolChains(k).isEmpty()) if (ToolchainKitAspect::toolChains(k).isEmpty())
result.append(createProjectTask(Task::TaskType::Warning, Tr::tr("No compilers set in kit."))); result.append(createProjectTask(Task::TaskType::Warning, Tr::tr("No compilers set in kit.")));
result.append(m_issues); result.append(m_issues);

8
src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
View File

@@ -937,7 +937,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (!Utils::contains(allLanguages, if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; })) [&tcd](const Id &language) { return language == tcd.language; }))
continue; continue;
Toolchain *tc = ToolChainKitAspect::toolChain(k, tcd.language); Toolchain *tc = ToolchainKitAspect::toolChain(k, tcd.language);
if ((!tc || !tc->matchesCompilerCommand(tcd.compilerPath))) { if ((!tc || !tc->matchesCompilerCommand(tcd.compilerPath))) {
return false; return false;
} }
@@ -950,7 +950,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (!Utils::contains(allLanguages, if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; })) [&tcd](const Id &language) { return language == tcd.language; }))
continue; continue;
Toolchain *tc = ToolChainKitAspect::toolChain(k, tcd.language); Toolchain *tc = ToolchainKitAspect::toolChain(k, tcd.language);
if (tc && tc->matchesCompilerCommand(tcd.compilerPath)) { if (tc && tc->matchesCompilerCommand(tcd.compilerPath)) {
return false; return false;
} }
@@ -1001,10 +1001,10 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
if (tcd.areTemporary) { if (tcd.areTemporary) {
for (Toolchain *tc : tcd.tcs) for (Toolchain *tc : tcd.tcs)
addTemporaryData(ToolChainKitAspect::id(), tc->id(), k); addTemporaryData(ToolchainKitAspect::id(), tc->id(), k);
} }
ToolChainKitAspect::setToolChain(k, tcd.tcs.at(0)); ToolchainKitAspect::setToolChain(k, tcd.tcs.at(0));
} }
if (!data->cmakePresetDisplayname.isEmpty()) { if (!data->cmakePresetDisplayname.isEmpty()) {

4
src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp
View File

@@ -407,8 +407,8 @@ void CMakeManager::buildFile(Node *node)
return extension; return extension;
const auto toolchain = ProjectFile::isCxx(sourceKind) const auto toolchain = ProjectFile::isCxx(sourceKind)
? ToolChainKitAspect::cxxToolChain(target->kit()) ? ToolchainKitAspect::cxxToolChain(target->kit())
: ToolChainKitAspect::cToolChain(target->kit()); : ToolchainKitAspect::cToolChain(target->kit());
using namespace ProjectExplorer::Constants; using namespace ProjectExplorer::Constants;
static QSet<Id> objIds{ static QSet<Id> objIds{
CLANG_CL_TOOLCHAIN_TYPEID, CLANG_CL_TOOLCHAIN_TYPEID,

4
src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp
View File

@@ -108,7 +108,7 @@ QString compilerPath(QString pathFlag)
Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language) Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
{ {
if (flags.empty()) if (flags.empty())
return ToolChainKitAspect::toolChain(kit, language); return ToolchainKitAspect::toolChain(kit, language);
// Try exact compiler match. // Try exact compiler match.
const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front())); const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front()));
@@ -131,7 +131,7 @@ Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Ut
return toolchain; return toolchain;
} }
toolchain = ToolChainKitAspect::toolChain(kit, language); toolchain = ToolchainKitAspect::toolChain(kit, language);
qWarning() << "No matching toolchain found, use the default."; qWarning() << "No matching toolchain found, use the default.";
return toolchain; return toolchain;
} }

6
src/plugins/conan/conaninstallstep.cpp
View File

@@ -104,9 +104,9 @@ ConanInstallStep::ConanInstallStep(BuildStepList *bsl, Id id)
}); });
setSummaryUpdater([this]() -> QString { setSummaryUpdater([this]() -> QString {
QList<Toolchain *> tcList = ToolChainKitAspect::toolChains(target()->kit()); QList<Toolchain *> tcList = ToolchainKitAspect::toolChains(target()->kit());
if (tcList.isEmpty()) if (tcList.isEmpty())
return "<b>" + ToolChainKitAspect::msgNoToolChainInTarget() + "</b>"; return "<b>" + ToolchainKitAspect::msgNoToolChainInTarget() + "</b>";
ProcessParameters param; ProcessParameters param;
setupProcessParameters(&param); setupProcessParameters(&param);
return param.summary(displayName()); return param.summary(displayName());
@@ -124,7 +124,7 @@ bool ConanInstallStep::init()
if (!AbstractProcessStep::init()) if (!AbstractProcessStep::init())
return false; return false;
const QList<Toolchain *> tcList = ToolChainKitAspect::toolChains(target()->kit()); const QList<Toolchain *> tcList = ToolchainKitAspect::toolChains(target()->kit());
if (tcList.isEmpty()) { if (tcList.isEmpty()) {
emit addTask(Task::compilerMissingTask()); emit addTask(Task::compilerMissingTask());
emitFaultyConfigurationMessage(); emitFaultyConfigurationMessage();

2
src/plugins/cppcheck/cppcheckplugin.cpp
View File

@@ -135,7 +135,7 @@ void CppcheckPluginPrivate::updateManualRunAction()
const Target *target = ProjectManager::startupTarget(); const Target *target = ProjectManager::startupTarget();
const Utils::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID; const Utils::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
const bool canRun = target && project->projectLanguages().contains(cxx) const bool canRun = target && project->projectLanguages().contains(cxx)
&& ToolChainKitAspect::cxxToolChain(target->kit()); && ToolchainKitAspect::cxxToolChain(target->kit());
manualRunAction->setEnabled(canRun); manualRunAction->setEnabled(canRun);
} }

6
src/plugins/cppeditor/cppmodelmanager.cpp
View File

@@ -412,9 +412,9 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
const Toolchain * tc = nullptr; const Toolchain * tc = nullptr;
const ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString())); const ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString()));
if (classifier.isC()) { if (classifier.isC()) {
tc = ToolChainKitAspect::cToolChain(project->activeTarget()->kit()); tc = ToolchainKitAspect::cToolChain(project->activeTarget()->kit());
} else if (classifier.isCxx() || classifier.isHeader()) { } else if (classifier.isCxx() || classifier.isHeader()) {
tc = ToolChainKitAspect::cxxToolChain(project->activeTarget()->kit()); tc = ToolchainKitAspect::cxxToolChain(project->activeTarget()->kit());
} else { } else {
showFallbackWarning(Tr::tr("Could not determine which compiler to invoke.")); showFallbackWarning(Tr::tr("Could not determine which compiler to invoke."));
useBuiltinPreprocessor(); useBuiltinPreprocessor();
@@ -1965,7 +1965,7 @@ void CppModelManager::setupFallbackProjectPart()
// TODO: Use different fallback toolchain for different kinds of files? // TODO: Use different fallback toolchain for different kinds of files?
const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr; const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr;
const Toolchain * const defaultTc = defaultKit const Toolchain * const defaultTc = defaultKit
? ToolChainKitAspect::cxxToolChain(defaultKit) : nullptr; ? ToolchainKitAspect::cxxToolChain(defaultKit) : nullptr;
if (defaultKit && defaultTc) { if (defaultKit && defaultTc) {
FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit); FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
if (sysroot.isEmpty()) if (sysroot.isEmpty())

4
src/plugins/debugger/debuggerkitaspect.cpp
View File

@@ -148,7 +148,7 @@ DebuggerKitAspect::ConfigurationErrors DebuggerKitAspect::configurationErrors(co
if (!debugger.isExecutableFile()) if (!debugger.isExecutableFile())
result |= DebuggerNotExecutable; result |= DebuggerNotExecutable;
const Abi tcAbi = ToolChainKitAspect::targetAbi(k); const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
if (item->matchTarget(tcAbi) == DebuggerItem::DoesNotMatch) { if (item->matchTarget(tcAbi) == DebuggerItem::DoesNotMatch) {
// currently restricting the check to desktop devices, may be extended to all device types // currently restricting the check to desktop devices, may be extended to all device types
const IDevice::ConstPtr device = DeviceKitAspect::device(k); const IDevice::ConstPtr device = DeviceKitAspect::device(k);
@@ -303,7 +303,7 @@ public:
// </valuemap> // </valuemap>
const QVariant rawId = k->value(DebuggerKitAspectFactory::id()); const QVariant rawId = k->value(DebuggerKitAspectFactory::id());
const Abi tcAbi = ToolChainKitAspect::targetAbi(k); const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
// Get the best of the available debugger matching the kit's toolchain. // Get the best of the available debugger matching the kit's toolchain.
// The general idea is to find an item that exactly matches what // The general idea is to find an item that exactly matches what

8
src/plugins/debugger/debuggerplugin.cpp
View File

@@ -533,7 +533,7 @@ static Kit::Predicate cdbPredicate(char wordWidth = 0)
return false; return false;
} }
if (wordWidth) if (wordWidth)
return ToolChainKitAspect::targetAbi(k).wordWidth() == wordWidth; return ToolchainKitAspect::targetAbi(k).wordWidth() == wordWidth;
return true; return true;
}; };
} }
@@ -1308,13 +1308,13 @@ static Kit *guessKitFromAbis(const Abis &abis)
if (!abis.isEmpty()) { if (!abis.isEmpty()) {
// Try exact abis. // Try exact abis.
kit = KitManager::kit([abis](const Kit *k) { kit = KitManager::kit([abis](const Kit *k) {
const Abi tcAbi = ToolChainKitAspect::targetAbi(k); const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
return abis.contains(tcAbi) && !DebuggerKitAspect::configurationErrors(k); return abis.contains(tcAbi) && !DebuggerKitAspect::configurationErrors(k);
}); });
if (!kit) { if (!kit) {
// Or something compatible. // Or something compatible.
kit = KitManager::kit([abis](const Kit *k) { kit = KitManager::kit([abis](const Kit *k) {
const Abi tcAbi = ToolChainKitAspect::targetAbi(k); const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
return !DebuggerKitAspect::configurationErrors(k) return !DebuggerKitAspect::configurationErrors(k)
&& Utils::contains(abis, [tcAbi](const Abi &a) { return a.isCompatibleWith(tcAbi); }); && Utils::contains(abis, [tcAbi](const Abi &a) { return a.isCompatibleWith(tcAbi); });
}); });
@@ -1764,7 +1764,7 @@ RunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
return nullptr; return nullptr;
} }
const Abi tcAbi = ToolChainKitAspect::targetAbi(kit); const Abi tcAbi = ToolchainKitAspect::targetAbi(kit);
const bool isWindows = (tcAbi.os() == Abi::WindowsOS); const bool isWindows = (tcAbi.os() == Abi::WindowsOS);
if (isWindows && isWinProcessBeingDebugged(processInfo.processId)) { if (isWindows && isWinProcessBeingDebugged(processInfo.processId)) {
AsynchronousMessageBox::warning( AsynchronousMessageBox::warning(

2
src/plugins/debugger/debuggerruncontrol.cpp
View File

@@ -900,7 +900,7 @@ DebuggerRunTool::DebuggerRunTool(RunControl *runControl, AllowTerminal allowTerm
m_runParameters.projectSourceFiles.clear(); m_runParameters.projectSourceFiles.clear();
} }
m_runParameters.toolChainAbi = ToolChainKitAspect::targetAbi(kit); m_runParameters.toolChainAbi = ToolchainKitAspect::targetAbi(kit);
bool ok = false; bool ok = false;
const int nativeMixedOverride = qtcEnvironmentVariableIntValue("QTC_DEBUGGER_NATIVE_MIXED", &ok); const int nativeMixedOverride = qtcEnvironmentVariableIntValue("QTC_DEBUGGER_NATIVE_MIXED", &ok);

2
src/plugins/debugger/unstartedappwatcherdialog.cpp
View File

@@ -72,7 +72,7 @@ UnstartedAppWatcherDialog::UnstartedAppWatcherDialog(QWidget *parent)
m_kitChooser = new KitChooser(this); m_kitChooser = new KitChooser(this);
m_kitChooser->setKitPredicate([](const Kit *k) { m_kitChooser->setKitPredicate([](const Kit *k) {
return ToolChainKitAspect::targetAbi(k).os() == Abi::hostAbi().os(); return ToolchainKitAspect::targetAbi(k).os() == Abi::hostAbi().os();
}); });
m_kitChooser->setShowIcons(true); m_kitChooser->setShowIcons(true);
m_kitChooser->populate(); m_kitChooser->populate();

4
src/plugins/docker/kitdetector.cpp
View File

@@ -364,12 +364,12 @@ void KitDetectorPrivate::autoDetect()
&& (!qt || qt->qtAbis().contains(tc->targetAbi())); && (!qt || qt->qtAbis().contains(tc->targetAbi()));
}); });
for (Toolchain *toolChain : toolchainsToSet) for (Toolchain *toolChain : toolchainsToSet)
ToolChainKitAspect::setToolChain(k, toolChain); ToolchainKitAspect::setToolChain(k, toolChain);
if (cmakeId.isValid()) if (cmakeId.isValid())
k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true); k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true);
k->setSticky(ToolChainKitAspect::id(), true); k->setSticky(ToolchainKitAspect::id(), true);
k->setSticky(QtSupport::QtKitAspect::id(), true); k->setSticky(QtSupport::QtKitAspect::id(), true);
k->setSticky(DeviceKitAspect::id(), true); k->setSticky(DeviceKitAspect::id(), true);
k->setSticky(DeviceTypeKitAspect::id(), true); k->setSticky(DeviceTypeKitAspect::id(), true);

2
src/plugins/incredibuild/makecommandbuilder.cpp
View File

@@ -37,7 +37,7 @@ FilePath MakeCommandBuilder::defaultCommand() const
{ {
if (BuildConfiguration *buildConfig = buildStep()->buildConfiguration()) { if (BuildConfiguration *buildConfig = buildStep()->buildConfiguration()) {
if (Target *target = buildStep()->target()) { if (Target *target = buildStep()->target()) {
if (Toolchain *toolChain = ToolChainKitAspect::cxxToolChain(target->kit())) if (Toolchain *toolChain = ToolchainKitAspect::cxxToolChain(target->kit()))
return toolChain->makeCommand(buildConfig->environment()); return toolChain->makeCommand(buildConfig->environment());
} }
} }

4
src/plugins/ios/iosbuildstep.cpp
View File

@@ -148,7 +148,7 @@ bool IosBuildStep::init()
if (!AbstractProcessStep::init()) if (!AbstractProcessStep::init())
return false; return false;
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit()); Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
if (!tc) { if (!tc) {
emit addTask(Task::compilerMissingTask()); emit addTask(Task::compilerMissingTask());
emitFaultyConfigurationMessage(); emitFaultyConfigurationMessage();
@@ -195,7 +195,7 @@ QStringList IosBuildStep::defaultArguments() const
{ {
QStringList res; QStringList res;
Kit *kit = target()->kit(); Kit *kit = target()->kit();
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit); Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
switch (buildConfiguration()->buildType()) { switch (buildConfiguration()->buildType()) {
case BuildConfiguration::Debug : case BuildConfiguration::Debug :
res << "-configuration" << "Debug"; res << "-configuration" << "Debug";

14
src/plugins/ios/iosconfigurations.cpp
View File

@@ -171,13 +171,13 @@ static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains,
{ {
DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType); DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
if (toolChains.first) if (toolChains.first)
ToolChainKitAspect::setToolChain(kit, toolChains.first); ToolchainKitAspect::setToolChain(kit, toolChains.first);
else else
ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID); ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
if (toolChains.second) if (toolChains.second)
ToolChainKitAspect::setToolChain(kit, toolChains.second); ToolchainKitAspect::setToolChain(kit, toolChains.second);
else else
ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID); ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QtKitAspect::setQtVersion(kit, qtVersion); QtKitAspect::setQtVersion(kit, qtVersion);
// only replace debugger with the default one if we find an unusable one here // only replace debugger with the default one if we find an unusable one here
@@ -190,7 +190,7 @@ static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains,
kit->setMutable(DeviceKitAspect::id(), true); kit->setMutable(DeviceKitAspect::id(), true);
kit->setSticky(QtKitAspect::id(), true); kit->setSticky(QtKitAspect::id(), true);
kit->setSticky(ToolChainKitAspect::id(), true); kit->setSticky(ToolchainKitAspect::id(), true);
kit->setSticky(DeviceTypeKitAspect::id(), true); kit->setSticky(DeviceTypeKitAspect::id(), true);
kit->setSticky(SysRootKitAspect::id(), true); kit->setSticky(SysRootKitAspect::id(), true);
kit->setSticky(DebuggerKitAspect::id(), false); kit->setSticky(DebuggerKitAspect::id(), false);
@@ -274,8 +274,8 @@ void IosConfigurations::updateAutomaticKitList()
// we do not compare the sdk (thus automatically upgrading it in place if a // we do not compare the sdk (thus automatically upgrading it in place if a
// new Xcode is used). Change? // new Xcode is used). Change?
return DeviceTypeKitAspect::deviceTypeId(kit) == pDeviceType return DeviceTypeKitAspect::deviceTypeId(kit) == pDeviceType
&& ToolChainKitAspect::cxxToolChain(kit) == platformToolchains.second && ToolchainKitAspect::cxxToolChain(kit) == platformToolchains.second
&& ToolChainKitAspect::cToolChain(kit) == platformToolchains.first && ToolchainKitAspect::cToolChain(kit) == platformToolchains.first
&& QtKitAspect::qtVersion(kit) == qtVersion; && QtKitAspect::qtVersion(kit) == qtVersion;
}); });
QTC_ASSERT(!resultingKits.contains(kit), continue); QTC_ASSERT(!resultingKits.contains(kit), continue);

4
src/plugins/mcusupport/mcukitmanager.cpp
View File

@@ -86,10 +86,10 @@ public:
case McuToolChainPackage::ToolChainType::GCC: case McuToolChainPackage::ToolChainType::GCC:
case McuToolChainPackage::ToolChainType::MinGW: case McuToolChainPackage::ToolChainType::MinGW:
case McuToolChainPackage::ToolChainType::ArmGcc: case McuToolChainPackage::ToolChainType::ArmGcc:
ToolChainKitAspect::setToolChain(k, ToolchainKitAspect::setToolChain(k,
tcPackage->toolChain( tcPackage->toolChain(
ProjectExplorer::Constants::C_LANGUAGE_ID)); ProjectExplorer::Constants::C_LANGUAGE_ID));
ToolChainKitAspect::setToolChain(k, ToolchainKitAspect::setToolChain(k,
tcPackage->toolChain( tcPackage->toolChain(
ProjectExplorer::Constants::CXX_LANGUAGE_ID)); ProjectExplorer::Constants::CXX_LANGUAGE_ID));
return; return;

2
src/plugins/mesonprojectmanager/mesonproject.cpp
View File

@@ -39,7 +39,7 @@ Tasks MesonProject::projectIssues(const Kit *k) const
if (!NinjaToolKitAspect::isValid(k)) if (!NinjaToolKitAspect::isValid(k))
result.append( result.append(
createProjectTask(Task::TaskType::Error, Tr::tr("No Ninja tool set."))); createProjectTask(Task::TaskType::Error, Tr::tr("No Ninja tool set.")));
if (ToolChainKitAspect::toolChains(k).isEmpty()) if (ToolchainKitAspect::toolChains(k).isEmpty())
result.append(createProjectTask(Task::TaskType::Warning, result.append(createProjectTask(Task::TaskType::Warning,
Tr::tr("No compilers set in kit."))); Tr::tr("No compilers set in kit.")));
return result; return result;

2
src/plugins/nim/project/nimbuildsystem.cpp
View File

@@ -169,7 +169,7 @@ void NimBuildSystem::triggerParsing()
FilePath nimPathFromKit(Kit *kit) FilePath nimPathFromKit(Kit *kit)
{ {
auto tc = ToolChainKitAspect::toolChain(kit, Constants::C_NIMLANGUAGE_ID); auto tc = ToolchainKitAspect::toolChain(kit, Constants::C_NIMLANGUAGE_ID);
QTC_ASSERT(tc, return {}); QTC_ASSERT(tc, return {});
const FilePath command = tc->compilerCommand(); const FilePath command = tc->compilerCommand();
return command.isEmpty() ? FilePath() : command.absolutePath(); return command.isEmpty() ? FilePath() : command.absolutePath();

2
src/plugins/nim/project/nimcompilerbuildstep.cpp
View File

@@ -159,7 +159,7 @@ CommandLine NimCompilerBuildStep::commandLine()
auto bc = qobject_cast<NimBuildConfiguration *>(buildConfiguration()); auto bc = qobject_cast<NimBuildConfiguration *>(buildConfiguration());
QTC_ASSERT(bc, return {}); QTC_ASSERT(bc, return {});
auto tc = ToolChainKitAspect::toolChain(kit(), Constants::C_NIMLANGUAGE_ID); auto tc = ToolchainKitAspect::toolChain(kit(), Constants::C_NIMLANGUAGE_ID);
QTC_ASSERT(tc, return {}); QTC_ASSERT(tc, return {});
CommandLine cmd{tc->compilerCommand()}; CommandLine cmd{tc->compilerCommand()};

2
src/plugins/nim/project/nimproject.cpp
View File

@@ -52,7 +52,7 @@ NimProject::NimProject(const FilePath &filePath) : Project(Constants::C_NIM_MIME
Tasks NimProject::projectIssues(const Kit *k) const Tasks NimProject::projectIssues(const Kit *k) const
{ {
Tasks result = Project::projectIssues(k); Tasks result = Project::projectIssues(k);
auto tc = ToolChainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID); auto tc = ToolchainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID);
if (!tc) { if (!tc) {
result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Nim compiler set."))); result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Nim compiler set.")));
return result; return result;

2
src/plugins/perfprofiler/perfdatareader.cpp
View File

@@ -288,7 +288,7 @@ void PerfDataReader::collectArguments(CommandLine *cmd, const QString &exe, cons
.arg(cmd->executable().osType() == OsTypeWindows ? u';' : u':')); .arg(cmd->executable().osType() == OsTypeWindows ? u';' : u':'));
} }
if (auto toolChain = ToolChainKitAspect::cxxToolChain(kit)) { if (auto toolChain = ToolchainKitAspect::cxxToolChain(kit)) {
Abi::Architecture architecture = toolChain->targetAbi().architecture(); Abi::Architecture architecture = toolChain->targetAbi().architecture();
if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) { if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) {
cmd->addArg("--arch"); cmd->addArg("--arch");

124
src/plugins/projectexplorer/kitaspects.cpp
View File

@@ -160,7 +160,7 @@ FilePath SysRootKitAspect::sysRoot(const Kit *k)
if (!k->value(SysRootKitAspect::id()).toString().isEmpty()) if (!k->value(SysRootKitAspect::id()).toString().isEmpty())
return FilePath::fromSettings(k->value(SysRootKitAspect::id())); return FilePath::fromSettings(k->value(SysRootKitAspect::id()));
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) { for (Toolchain *tc : ToolchainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty()) if (!tc->sysRoot().isEmpty())
return FilePath::fromString(tc->sysRoot()); return FilePath::fromString(tc->sysRoot());
} }
@@ -172,7 +172,7 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
if (!k) if (!k)
return; return;
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) { for (Toolchain *tc : ToolchainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty()) { if (!tc->sysRoot().isEmpty()) {
// It's the sysroot from toolchain, don't set it. // It's the sysroot from toolchain, don't set it.
if (tc->sysRoot() == v.toString()) if (tc->sysRoot() == v.toString())
@@ -188,14 +188,14 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
const SysRootKitAspectFactory theSyRootKitAspectFactory; const SysRootKitAspectFactory theSyRootKitAspectFactory;
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// ToolChainKitAspect: // ToolchainKitAspect:
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
namespace Internal { namespace Internal {
class ToolChainKitAspectImpl final : public KitAspect class ToolchainKitAspectImpl final : public KitAspect
{ {
public: public:
ToolChainKitAspectImpl(Kit *k, const KitAspectFactory *factory) : KitAspect(k, factory) ToolchainKitAspectImpl(Kit *k, const KitAspectFactory *factory) : KitAspect(k, factory)
{ {
m_mainWidget = createSubWidget<QWidget>(); m_mainWidget = createSubWidget<QWidget>();
m_mainWidget->setContentsMargins(0, 0, 0, 0); m_mainWidget->setContentsMargins(0, 0, 0, 0);
@@ -230,7 +230,7 @@ public:
setManagingPage(Constants::TOOLCHAIN_SETTINGS_PAGE_ID); setManagingPage(Constants::TOOLCHAIN_SETTINGS_PAGE_ID);
} }
~ToolChainKitAspectImpl() override ~ToolchainKitAspectImpl() override
{ {
delete m_mainWidget; delete m_mainWidget;
} }
@@ -272,7 +272,7 @@ private:
cb->addItem(item->displayName(), item->id()); cb->addItem(item->displayName(), item->id());
cb->setEnabled(cb->count() > 1 && !m_isReadOnly); cb->setEnabled(cb->count() > 1 && !m_isReadOnly);
const int index = indexOf(cb, ToolChainKitAspect::toolChain(m_kit, l)); const int index = indexOf(cb, ToolchainKitAspect::toolChain(m_kit, l));
cb->setCurrentIndex(index); cb->setCurrentIndex(index);
} }
} }
@@ -295,9 +295,9 @@ private:
Toolchain *tc = ToolChainManager::findToolChain(id); Toolchain *tc = ToolChainManager::findToolChain(id);
QTC_ASSERT(!tc || tc->language() == language, return); QTC_ASSERT(!tc || tc->language() == language, return);
if (tc) if (tc)
ToolChainKitAspect::setToolChain(m_kit, tc); ToolchainKitAspect::setToolChain(m_kit, tc);
else else
ToolChainKitAspect::clearToolChain(m_kit, language); ToolchainKitAspect::clearToolChain(m_kit, language);
} }
int indexOf(QComboBox *cb, const Toolchain *tc) int indexOf(QComboBox *cb, const Toolchain *tc)
@@ -317,10 +317,10 @@ private:
}; };
} // namespace Internal } // namespace Internal
class ToolChainKitAspectFactory : public KitAspectFactory class ToolchainKitAspectFactory : public KitAspectFactory
{ {
public: public:
ToolChainKitAspectFactory(); ToolchainKitAspectFactory();
private: private:
Tasks validate(const Kit *k) const override; Tasks validate(const Kit *k) const override;
@@ -346,9 +346,9 @@ private:
void toolChainRemoved(Toolchain *tc); void toolChainRemoved(Toolchain *tc);
}; };
ToolChainKitAspectFactory::ToolChainKitAspectFactory() ToolchainKitAspectFactory::ToolchainKitAspectFactory()
{ {
setId(ToolChainKitAspect::id()); setId(ToolchainKitAspect::id());
setDisplayName(Tr::tr("Compiler")); setDisplayName(Tr::tr("Compiler"));
setDescription(Tr::tr("The compiler to use for building.<br>" setDescription(Tr::tr("The compiler to use for building.<br>"
"Make sure the compiler will produce binaries compatible " "Make sure the compiler will produce binaries compatible "
@@ -380,13 +380,13 @@ static Store defaultToolChainValue()
return result; return result;
} }
Tasks ToolChainKitAspectFactory::validate(const Kit *k) const Tasks ToolchainKitAspectFactory::validate(const Kit *k) const
{ {
Tasks result; Tasks result;
const QList<Toolchain*> tcList = ToolChainKitAspect::toolChains(k); const QList<Toolchain*> tcList = ToolchainKitAspect::toolChains(k);
if (tcList.isEmpty()) { if (tcList.isEmpty()) {
result << BuildSystemTask(Task::Warning, ToolChainKitAspect::msgNoToolChainInTarget()); result << BuildSystemTask(Task::Warning, ToolchainKitAspect::msgNoToolChainInTarget());
} else { } else {
QSet<Abi> targetAbis; QSet<Abi> targetAbis;
for (const Toolchain *tc : tcList) { for (const Toolchain *tc : tcList) {
@@ -402,17 +402,17 @@ Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
return result; return result;
} }
void ToolChainKitAspectFactory::fix(Kit *k) void ToolchainKitAspectFactory::fix(Kit *k)
{ {
QTC_ASSERT(ToolChainManager::isLoaded(), return); QTC_ASSERT(ToolChainManager::isLoaded(), return);
const QList<Id> languages = ToolChainManager::allLanguages(); const QList<Id> languages = ToolChainManager::allLanguages();
for (const Id l : languages) { for (const Id l : languages) {
const QByteArray tcId = ToolChainKitAspect::toolChainId(k, l); const QByteArray tcId = ToolchainKitAspect::toolChainId(k, l);
if (!tcId.isEmpty() && !ToolChainManager::findToolChain(tcId)) { if (!tcId.isEmpty() && !ToolChainManager::findToolChain(tcId)) {
qWarning("Tool chain set up in kit \"%s\" for \"%s\" not found.", qWarning("Tool chain set up in kit \"%s\" for \"%s\" not found.",
qPrintable(k->displayName()), qPrintable(k->displayName()),
qPrintable(ToolChainManager::displayNameOfLanguageId(l))); qPrintable(ToolChainManager::displayNameOfLanguageId(l)));
ToolChainKitAspect::clearToolChain(k, l); // make sure to clear out no longer known tool chains ToolchainKitAspect::clearToolChain(k, l); // make sure to clear out no longer known tool chains
} }
} }
} }
@@ -424,7 +424,7 @@ static Id findLanguage(const QString &ls)
[lsUpper](Id l) { return lsUpper == l.toString().toUpper(); }); [lsUpper](Id l) { return lsUpper == l.toString().toUpper(); });
} }
void ToolChainKitAspectFactory::setup(Kit *k) void ToolchainKitAspectFactory::setup(Kit *k)
{ {
QTC_ASSERT(ToolChainManager::isLoaded(), return); QTC_ASSERT(ToolChainManager::isLoaded(), return);
QTC_ASSERT(k, return); QTC_ASSERT(k, return);
@@ -459,123 +459,123 @@ void ToolChainKitAspectFactory::setup(Kit *k)
bestTc = tc; bestTc = tc;
} }
if (bestTc) if (bestTc)
ToolChainKitAspect::setToolChain(k, bestTc); ToolchainKitAspect::setToolChain(k, bestTc);
else else
ToolChainKitAspect::clearToolChain(k, l); ToolchainKitAspect::clearToolChain(k, l);
} }
k->setSticky(id(), lockToolchains); k->setSticky(id(), lockToolchains);
} }
KitAspect *ToolChainKitAspectFactory::createKitAspect(Kit *k) const KitAspect *ToolchainKitAspectFactory::createKitAspect(Kit *k) const
{ {
QTC_ASSERT(k, return nullptr); QTC_ASSERT(k, return nullptr);
return new Internal::ToolChainKitAspectImpl(k, this); return new Internal::ToolchainKitAspectImpl(k, this);
} }
QString ToolChainKitAspectFactory::displayNamePostfix(const Kit *k) const QString ToolchainKitAspectFactory::displayNamePostfix(const Kit *k) const
{ {
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k); Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
return tc ? tc->displayName() : QString(); return tc ? tc->displayName() : QString();
} }
KitAspectFactory::ItemList ToolChainKitAspectFactory::toUserOutput(const Kit *k) const KitAspectFactory::ItemList ToolchainKitAspectFactory::toUserOutput(const Kit *k) const
{ {
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k); Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
return {{Tr::tr("Compiler"), tc ? tc->displayName() : Tr::tr("None")}}; return {{Tr::tr("Compiler"), tc ? tc->displayName() : Tr::tr("None")}};
} }
void ToolChainKitAspectFactory::addToBuildEnvironment(const Kit *k, Environment &env) const void ToolchainKitAspectFactory::addToBuildEnvironment(const Kit *k, Environment &env) const
{ {
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k); Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
if (tc) if (tc)
tc->addToEnvironment(env); tc->addToEnvironment(env);
} }
void ToolChainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expander) const void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expander) const
{ {
QTC_ASSERT(kit, return); QTC_ASSERT(kit, return);
// Compatibility with Qt Creator < 4.2: // Compatibility with Qt Creator < 4.2:
expander->registerVariable("Compiler:Name", Tr::tr("Compiler"), expander->registerVariable("Compiler:Name", Tr::tr("Compiler"),
[kit] { [kit] {
const Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit); const Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
return tc ? tc->displayName() : Tr::tr("None"); return tc ? tc->displayName() : Tr::tr("None");
}); });
expander->registerVariable("Compiler:Executable", Tr::tr("Path to the compiler executable"), expander->registerVariable("Compiler:Executable", Tr::tr("Path to the compiler executable"),
[kit] { [kit] {
const Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit); const Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
return tc ? tc->compilerCommand().path() : QString(); return tc ? tc->compilerCommand().path() : QString();
}); });
// After 4.2 // After 4.2
expander->registerPrefix("Compiler:Name", Tr::tr("Compiler for different languages"), expander->registerPrefix("Compiler:Name", Tr::tr("Compiler for different languages"),
[kit](const QString &ls) { [kit](const QString &ls) {
const Toolchain *tc = ToolChainKitAspect::toolChain(kit, findLanguage(ls)); const Toolchain *tc = ToolchainKitAspect::toolChain(kit, findLanguage(ls));
return tc ? tc->displayName() : Tr::tr("None"); return tc ? tc->displayName() : Tr::tr("None");
}); });
expander->registerPrefix("Compiler:Executable", Tr::tr("Compiler executable for different languages"), expander->registerPrefix("Compiler:Executable", Tr::tr("Compiler executable for different languages"),
[kit](const QString &ls) { [kit](const QString &ls) {
const Toolchain *tc = ToolChainKitAspect::toolChain(kit, findLanguage(ls)); const Toolchain *tc = ToolchainKitAspect::toolChain(kit, findLanguage(ls));
return tc ? tc->compilerCommand().path() : QString(); return tc ? tc->compilerCommand().path() : QString();
}); });
} }
QList<OutputLineParser *> ToolChainKitAspectFactory::createOutputParsers(const Kit *k) const QList<OutputLineParser *> ToolchainKitAspectFactory::createOutputParsers(const Kit *k) const
{ {
for (const Id langId : {Constants::CXX_LANGUAGE_ID, Constants::C_LANGUAGE_ID}) { for (const Id langId : {Constants::CXX_LANGUAGE_ID, Constants::C_LANGUAGE_ID}) {
if (const Toolchain * const tc = ToolChainKitAspect::toolChain(k, langId)) if (const Toolchain * const tc = ToolchainKitAspect::toolChain(k, langId))
return tc->createOutputParsers(); return tc->createOutputParsers();
} }
return {}; return {};
} }
QSet<Id> ToolChainKitAspectFactory::availableFeatures(const Kit *k) const QSet<Id> ToolchainKitAspectFactory::availableFeatures(const Kit *k) const
{ {
QSet<Id> result; QSet<Id> result;
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) for (Toolchain *tc : ToolchainKitAspect::toolChains(k))
result.insert(tc->typeId().withPrefix("ToolChain.")); result.insert(tc->typeId().withPrefix("ToolChain."));
return result; return result;
} }
Id ToolChainKitAspect::id() Id ToolchainKitAspect::id()
{ {
// "PE.Profile.ToolChain" until 4.2 // "PE.Profile.ToolChain" until 4.2
// "PE.Profile.ToolChains" temporarily before 4.3 (May 2017) // "PE.Profile.ToolChains" temporarily before 4.3 (May 2017)
return "PE.Profile.ToolChainsV3"; return "PE.Profile.ToolChainsV3";
} }
QByteArray ToolChainKitAspect::toolChainId(const Kit *k, Id language) QByteArray ToolchainKitAspect::toolChainId(const Kit *k, Id language)
{ {
QTC_ASSERT(ToolChainManager::isLoaded(), return nullptr); QTC_ASSERT(ToolChainManager::isLoaded(), return nullptr);
if (!k) if (!k)
return {}; return {};
Store value = storeFromVariant(k->value(ToolChainKitAspect::id())); Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
return value.value(language.toKey(), QByteArray()).toByteArray(); return value.value(language.toKey(), QByteArray()).toByteArray();
} }
Toolchain *ToolChainKitAspect::toolChain(const Kit *k, Id language) Toolchain *ToolchainKitAspect::toolChain(const Kit *k, Id language)
{ {
return ToolChainManager::findToolChain(toolChainId(k, language)); return ToolChainManager::findToolChain(toolChainId(k, language));
} }
Toolchain *ToolChainKitAspect::cToolChain(const Kit *k) Toolchain *ToolchainKitAspect::cToolChain(const Kit *k)
{ {
return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID)); return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
} }
Toolchain *ToolChainKitAspect::cxxToolChain(const Kit *k) Toolchain *ToolchainKitAspect::cxxToolChain(const Kit *k)
{ {
return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID)); return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
} }
QList<Toolchain *> ToolChainKitAspect::toolChains(const Kit *k) QList<Toolchain *> ToolchainKitAspect::toolChains(const Kit *k)
{ {
QTC_ASSERT(k, return {}); QTC_ASSERT(k, return {});
const Store value = storeFromVariant(k->value(ToolChainKitAspect::id())); const Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
const QList<Toolchain *> tcList const QList<Toolchain *> tcList
= transform<QList>(ToolChainManager::allLanguages(), [&value](Id l) { = transform<QList>(ToolChainManager::allLanguages(), [&value](Id l) {
return ToolChainManager::findToolChain(value.value(l.toKey()).toByteArray()); return ToolChainManager::findToolChain(value.value(l.toKey()).toByteArray());
@@ -583,11 +583,11 @@ QList<Toolchain *> ToolChainKitAspect::toolChains(const Kit *k)
return filtered(tcList, [](Toolchain *tc) { return tc; }); return filtered(tcList, [](Toolchain *tc) { return tc; });
} }
void ToolChainKitAspect::setToolChain(Kit *k, Toolchain *tc) void ToolchainKitAspect::setToolChain(Kit *k, Toolchain *tc)
{ {
QTC_ASSERT(tc, return); QTC_ASSERT(tc, return);
QTC_ASSERT(k, return); QTC_ASSERT(k, return);
Store result = storeFromVariant(k->value(ToolChainKitAspect::id())); Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
result.insert(tc->language().toKey(), tc->id()); result.insert(tc->language().toKey(), tc->id());
k->setValue(id(), variantFromStore(result)); k->setValue(id(), variantFromStore(result));
@@ -603,7 +603,7 @@ void ToolChainKitAspect::setToolChain(Kit *k, Toolchain *tc)
* @param k The kit to set up * @param k The kit to set up
* @param tc The toolchain to match other languages for. * @param tc The toolchain to match other languages for.
*/ */
void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc) void ToolchainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
{ {
QTC_ASSERT(tc, return); QTC_ASSERT(tc, return);
QTC_ASSERT(k, return); QTC_ASSERT(k, return);
@@ -611,7 +611,7 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
const Toolchains allTcList = ToolChainManager::toolchains(); const Toolchains allTcList = ToolChainManager::toolchains();
QTC_ASSERT(allTcList.contains(tc), return); QTC_ASSERT(allTcList.contains(tc), return);
Store result = storeFromVariant(k->value(ToolChainKitAspect::id())); Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
result.insert(tc->language().toKey(), tc->id()); result.insert(tc->language().toKey(), tc->id());
for (const Id l : ToolChainManager::allLanguages()) { for (const Id l : ToolChainManager::allLanguages()) {
@@ -642,17 +642,17 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
k->setValue(id(), variantFromStore(result)); k->setValue(id(), variantFromStore(result));
} }
void ToolChainKitAspect::clearToolChain(Kit *k, Id language) void ToolchainKitAspect::clearToolChain(Kit *k, Id language)
{ {
QTC_ASSERT(language.isValid(), return); QTC_ASSERT(language.isValid(), return);
QTC_ASSERT(k, return); QTC_ASSERT(k, return);
Store result = storeFromVariant(k->value(ToolChainKitAspect::id())); Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
result.insert(language.toKey(), QByteArray()); result.insert(language.toKey(), QByteArray());
k->setValue(id(), variantFromStore(result)); k->setValue(id(), variantFromStore(result));
} }
Abi ToolChainKitAspect::targetAbi(const Kit *k) Abi ToolchainKitAspect::targetAbi(const Kit *k)
{ {
const QList<Toolchain *> tcList = toolChains(k); const QList<Toolchain *> tcList = toolChains(k);
// Find the best possible ABI for all the tool chains... // Find the best possible ABI for all the tool chains...
@@ -685,38 +685,38 @@ Abi ToolChainKitAspect::targetAbi(const Kit *k)
return candidates.at(0); // Use basically a random Abi... return candidates.at(0); // Use basically a random Abi...
} }
QString ToolChainKitAspect::msgNoToolChainInTarget() QString ToolchainKitAspect::msgNoToolChainInTarget()
{ {
return Tr::tr("No compiler set in kit."); return Tr::tr("No compiler set in kit.");
} }
void ToolChainKitAspectFactory::onKitsLoaded() void ToolchainKitAspectFactory::onKitsLoaded()
{ {
for (Kit *k : KitManager::kits()) for (Kit *k : KitManager::kits())
fix(k); fix(k);
connect(ToolChainManager::instance(), &ToolChainManager::toolChainRemoved, connect(ToolChainManager::instance(), &ToolChainManager::toolChainRemoved,
this, &ToolChainKitAspectFactory::toolChainRemoved); this, &ToolchainKitAspectFactory::toolChainRemoved);
connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated, connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
this, &ToolChainKitAspectFactory::toolChainUpdated); this, &ToolchainKitAspectFactory::toolChainUpdated);
} }
void ToolChainKitAspectFactory::toolChainUpdated(Toolchain *tc) void ToolchainKitAspectFactory::toolChainUpdated(Toolchain *tc)
{ {
for (Kit *k : KitManager::kits()) { for (Kit *k : KitManager::kits()) {
if (ToolChainKitAspect::toolChain(k, tc->language()) == tc) if (ToolchainKitAspect::toolChain(k, tc->language()) == tc)
notifyAboutUpdate(k); notifyAboutUpdate(k);
} }
} }
void ToolChainKitAspectFactory::toolChainRemoved(Toolchain *tc) void ToolchainKitAspectFactory::toolChainRemoved(Toolchain *tc)
{ {
Q_UNUSED(tc) Q_UNUSED(tc)
for (Kit *k : KitManager::kits()) for (Kit *k : KitManager::kits())
fix(k); fix(k);
} }
const ToolChainKitAspectFactory thsToolChainKitAspectFactory; const ToolchainKitAspectFactory thsToolChainKitAspectFactory;
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// DeviceTypeKitAspect: // DeviceTypeKitAspect:

2
src/plugins/projectexplorer/kitaspects.h
View File

@@ -26,7 +26,7 @@ public:
// ToolChainKitAspect // ToolChainKitAspect
class PROJECTEXPLORER_EXPORT ToolChainKitAspect class PROJECTEXPLORER_EXPORT ToolchainKitAspect
{ {
public: public:
static Utils::Id id(); static Utils::Id id();

10
src/plugins/projectexplorer/kitmanager.cpp
View File

@@ -151,7 +151,7 @@ void KitManager::destroy()
static bool kitMatchesAbiList(const Kit *kit, const Abis &abis) static bool kitMatchesAbiList(const Kit *kit, const Abis &abis)
{ {
const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit); const QList<Toolchain *> toolchains = ToolchainKitAspect::toolChains(kit);
for (const Toolchain * const tc : toolchains) { for (const Toolchain * const tc : toolchains) {
const Abi tcAbi = tc->targetAbi(); const Abi tcAbi = tc->targetAbi();
for (const Abi &abi : abis) { for (const Abi &abi : abis) {
@@ -183,7 +183,7 @@ static Id deviceTypeForKit(const Kit *kit)
{ {
if (isHostKit(kit)) if (isHostKit(kit))
return Constants::DESKTOP_DEVICE_TYPE; return Constants::DESKTOP_DEVICE_TYPE;
const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit); const QList<Toolchain *> toolchains = ToolchainKitAspect::toolChains(kit);
for (const Toolchain * const tc : toolchains) { for (const Toolchain * const tc : toolchains) {
const Abi tcAbi = tc->targetAbi(); const Abi tcAbi = tc->targetAbi();
switch (tcAbi.os()) { switch (tcAbi.os()) {
@@ -347,10 +347,10 @@ void KitManager::restoreKits()
kit->setSdkProvided(false); kit->setSdkProvided(false);
kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here? kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here?
for (Toolchain * const tc : it.value()) for (Toolchain * const tc : it.value())
ToolChainKitAspect::setToolChain(kit.get(), tc); ToolchainKitAspect::setToolChain(kit.get(), tc);
if (contains(resultList, [&kit](const std::unique_ptr<Kit> &existingKit) { if (contains(resultList, [&kit](const std::unique_ptr<Kit> &existingKit) {
return ToolChainKitAspect::toolChains(kit.get()) return ToolchainKitAspect::toolChains(kit.get())
== ToolChainKitAspect::toolChains(existingKit.get()); == ToolchainKitAspect::toolChains(existingKit.get());
})) { })) {
continue; continue;
} }

2
src/plugins/projectexplorer/makestep.cpp
View File

@@ -130,7 +130,7 @@ QString MakeStep::defaultDisplayName()
static const QList<Toolchain *> preferredToolChains(const Kit *kit) static const QList<Toolchain *> preferredToolChains(const Kit *kit)
{ {
// prefer CXX, then C, then others // prefer CXX, then C, then others
return Utils::sorted(ToolChainKitAspect::toolChains(kit), [](Toolchain *tcA, Toolchain *tcB) { return Utils::sorted(ToolchainKitAspect::toolChains(kit), [](Toolchain *tcA, Toolchain *tcB) {
if (tcA->language() == tcB->language()) if (tcA->language() == tcB->language())
return false; return false;
if (tcA->language() == Constants::CXX_LANGUAGE_ID) if (tcA->language() == Constants::CXX_LANGUAGE_ID)

4
src/plugins/projectexplorer/project.cpp
View File

@@ -1551,12 +1551,12 @@ void ProjectExplorerPlugin::testSourceToBinaryMapping()
{ {
// Find suitable kit. // Find suitable kit.
Kit * const kit = findOr(KitManager::kits(), nullptr, [](const Kit *k) { Kit * const kit = findOr(KitManager::kits(), nullptr, [](const Kit *k) {
return k->isValid() && ToolChainKitAspect::cxxToolChain(k); return k->isValid() && ToolchainKitAspect::cxxToolChain(k);
}); });
if (!kit) if (!kit)
QSKIP("The test requires at least one kit with a toolchain."); QSKIP("The test requires at least one kit with a toolchain.");
const auto toolchain = ToolChainKitAspect::cxxToolChain(kit); const auto toolchain = ToolchainKitAspect::cxxToolChain(kit);
QVERIFY(toolchain); QVERIFY(toolchain);
if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) { if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) {
while (!msvcToolchain->environmentInitialized()) { while (!msvcToolchain->environmentInitialized()) {

8
src/plugins/projectexplorer/projectimporter.cpp
View File

@@ -53,7 +53,7 @@ static bool hasOtherUsers(Utils::Id id, const QVariant &v, Kit *k)
ProjectImporter::ProjectImporter(const Utils::FilePath &path) : m_projectPath(path) ProjectImporter::ProjectImporter(const Utils::FilePath &path) : m_projectPath(path)
{ {
useTemporaryKitAspect(ToolChainKitAspect::id(), useTemporaryKitAspect(ToolchainKitAspect::id(),
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(k, vl); }, [this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(k, vl); },
[this](Kit *k, const QVariantList &vl) { persistTemporaryToolChains(k, vl); }); [this](Kit *k, const QVariantList &vl) { persistTemporaryToolChains(k, vl); });
} }
@@ -322,7 +322,7 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
Toolchain *tc = toolChainFromVariant(v); Toolchain *tc = toolChainFromVariant(v);
QTC_ASSERT(tc, continue); QTC_ASSERT(tc, continue);
ToolChainManager::deregisterToolChain(tc); ToolChainManager::deregisterToolChain(tc);
ToolChainKitAspect::setToolChain(k, nullptr); ToolchainKitAspect::setToolChain(k, nullptr);
} }
} }
@@ -331,7 +331,7 @@ void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
for (const QVariant &v : vl) { for (const QVariant &v : vl) {
Toolchain *tmpTc = toolChainFromVariant(v); Toolchain *tmpTc = toolChainFromVariant(v);
QTC_ASSERT(tmpTc, continue); QTC_ASSERT(tmpTc, continue);
Toolchain *actualTc = ToolChainKitAspect::toolChain(k, tmpTc->language()); Toolchain *actualTc = ToolchainKitAspect::toolChain(k, tmpTc->language());
if (tmpTc && actualTc != tmpTc) if (tmpTc && actualTc != tmpTc)
ToolChainManager::deregisterToolChain(tmpTc); ToolChainManager::deregisterToolChain(tmpTc);
} }
@@ -394,7 +394,7 @@ ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
}); });
for (const Toolchain *tc : std::as_const(result.tcs)) { for (const Toolchain *tc : std::as_const(result.tcs)) {
const QByteArray tcId = tc->id(); const QByteArray tcId = tc->id();
result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolChainKitAspect::id(), tcId); result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolchainKitAspect::id(), tcId);
} }
if (!result.tcs.isEmpty()) if (!result.tcs.isEmpty())
return result; return result;

4
src/plugins/projectexplorer/rawprojectpart.cpp
View File

@@ -142,8 +142,8 @@ KitInfo::KitInfo(Kit *kit)
{ {
// Toolchains // Toolchains
if (kit) { if (kit) {
cToolChain = ToolChainKitAspect::cToolChain(kit); cToolChain = ToolchainKitAspect::cToolChain(kit);
cxxToolChain = ToolChainKitAspect::cxxToolChain(kit); cxxToolChain = ToolchainKitAspect::cxxToolChain(kit);
} }
// Sysroot // Sysroot

4
src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
View File

@@ -238,8 +238,8 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
if (!sysroot.isEmpty()) if (!sysroot.isEmpty())
data.insert(QLatin1String(QBS_SYSROOT), sysroot); data.insert(QLatin1String(QBS_SYSROOT), sysroot);
Toolchain *tcC = ToolChainKitAspect::cToolChain(k); Toolchain *tcC = ToolchainKitAspect::cToolChain(k);
Toolchain *tcCxx = ToolChainKitAspect::cxxToolChain(k); Toolchain *tcCxx = ToolchainKitAspect::cxxToolChain(k);
if (!tcC && !tcCxx) if (!tcC && !tcCxx)
return data; return data;

8
src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
View File

@@ -141,12 +141,12 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
const auto * const bgData = static_cast<BuildGraphData *>(directoryData); const auto * const bgData = static_cast<BuildGraphData *>(directoryData);
qCDebug(qbsPmLog) << "matching kit" << k->displayName() << "against imported build" qCDebug(qbsPmLog) << "matching kit" << k->displayName() << "against imported build"
<< bgData->bgFilePath.toUserOutput(); << bgData->bgFilePath.toUserOutput();
if (ToolChainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty() if (ToolchainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
&& bgData->cxxCompilerPath.isEmpty()) { && bgData->cxxCompilerPath.isEmpty()) {
return true; return true;
} }
const Toolchain * const cToolchain = ToolChainKitAspect::cToolChain(k); const Toolchain * const cToolchain = ToolchainKitAspect::cToolChain(k);
const Toolchain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k); const Toolchain * const cxxToolchain = ToolchainKitAspect::cxxToolChain(k);
if (!bgData->cCompilerPath.isEmpty()) { if (!bgData->cCompilerPath.isEmpty()) {
if (!cToolchain) if (!cToolchain)
return false; return false;
@@ -190,7 +190,7 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID}); tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
for (const ToolChainData &tc : std::as_const(tcData)) { for (const ToolChainData &tc : std::as_const(tcData)) {
if (!tc.tcs.isEmpty()) if (!tc.tcs.isEmpty())
ToolChainKitAspect::setToolChain(k, tc.tcs.first()); ToolchainKitAspect::setToolChain(k, tc.tcs.first());
} }
SysRootKitAspect::setSysRoot(k, bgData->sysroot); SysRootKitAspect::setSysRoot(k, bgData->sysroot);
}); });

2
src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
View File

@@ -781,7 +781,7 @@ QmakeBuildConfiguration::LastKitState::LastKitState(Kit *k)
m_sysroot(SysRootKitAspect::sysRoot(k).toString()), m_sysroot(SysRootKitAspect::sysRoot(k).toString()),
m_mkspec(QmakeKitAspect::mkspec(k)) m_mkspec(QmakeKitAspect::mkspec(k))
{ {
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k); Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
m_toolchain = tc ? tc->id() : QByteArray(); m_toolchain = tc ? tc->id() : QByteArray();
} }

2
src/plugins/qmakeprojectmanager/qmakekitaspect.cpp
View File

@@ -98,7 +98,7 @@ QString QmakeKitAspect::defaultMkspec(const Kit *k)
if (!version) // No version, so no qmake if (!version) // No version, so no qmake
return {}; return {};
return version->mkspecFor(ToolChainKitAspect::cxxToolChain(k)); return version->mkspecFor(ToolchainKitAspect::cxxToolChain(k));
} }
// QmakeKitAspectFactory // QmakeKitAspectFactory

2
src/plugins/qmakeprojectmanager/qmakemakestep.cpp
View File

@@ -179,7 +179,7 @@ bool QmakeMakeStep::init()
void QmakeMakeStep::setupOutputFormatter(OutputFormatter *formatter) void QmakeMakeStep::setupOutputFormatter(OutputFormatter *formatter)
{ {
formatter->addLineParser(new GnuMakeParser()); formatter->addLineParser(new GnuMakeParser());
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit()); Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
OutputTaskParser *xcodeBuildParser = nullptr; OutputTaskParser *xcodeBuildParser = nullptr;
if (tc && tc->targetAbi().os() == Abi::DarwinOS) { if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
xcodeBuildParser = new XcodebuildParser; xcodeBuildParser = new XcodebuildParser;

12
src/plugins/qmakeprojectmanager/qmakeproject.cpp
View File

@@ -238,7 +238,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated, connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
this, [this](Toolchain *tc) { this, [this](Toolchain *tc) {
if (ToolChainKitAspect::cxxToolChain(kit()) == tc) if (ToolchainKitAspect::cxxToolChain(kit()) == tc)
scheduleUpdateAllNowOrLater(); scheduleUpdateAllNowOrLater();
}); });
@@ -757,7 +757,7 @@ Tasks QmakeProject::projectIssues(const Kit *k) const
result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Qt version set in kit."))); result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Qt version set in kit.")));
else if (!qtFromKit->isValid()) else if (!qtFromKit->isValid())
result.append(createProjectTask(Task::TaskType::Error, Tr::tr("Qt version is invalid."))); result.append(createProjectTask(Task::TaskType::Error, Tr::tr("Qt version is invalid.")));
if (!ToolChainKitAspect::cxxToolChain(k)) if (!ToolchainKitAspect::cxxToolChain(k))
result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No C++ compiler set in kit."))); result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No C++ compiler set in kit.")));
// A project can be considered part of more than one Qt version, for instance if it is an // A project can be considered part of more than one Qt version, for instance if it is an
@@ -1308,7 +1308,7 @@ static FilePath destDirFor(const TargetInformation &ti)
FilePaths QmakeBuildSystem::allLibraryTargetFiles(const QmakeProFile *file) const FilePaths QmakeBuildSystem::allLibraryTargetFiles(const QmakeProFile *file) const
{ {
const Toolchain *const toolchain = ToolChainKitAspect::cxxToolChain(kit()); const Toolchain *const toolchain = ToolchainKitAspect::cxxToolChain(kit());
if (!toolchain) if (!toolchain)
return {}; return {};
@@ -1467,14 +1467,14 @@ QString QmakeBuildSystem::deviceRoot() const
void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
{ {
const BuildConfiguration *bc = buildConfiguration(); const BuildConfiguration *bc = buildConfiguration();
testToolChain(ToolChainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc)); testToolChain(ToolchainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
testToolChain(ToolChainKitAspect::cxxToolChain(kit()), testToolChain(ToolchainKitAspect::cxxToolChain(kit()),
getFullPathOf(pro, Variable::QmakeCxx, bc)); getFullPathOf(pro, Variable::QmakeCxx, bc));
} }
FilePath QmakeBuildSystem::executableFor(const QmakeProFile *file) FilePath QmakeBuildSystem::executableFor(const QmakeProFile *file)
{ {
const Toolchain *const tc = ToolChainKitAspect::cxxToolChain(kit()); const Toolchain *const tc = ToolchainKitAspect::cxxToolChain(kit());
if (!tc) if (!tc)
return {}; return {};

4
src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
View File

@@ -160,7 +160,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
QtVersion *kitVersion = QtKitAspect::qtVersion(k); QtVersion *kitVersion = QtKitAspect::qtVersion(k);
QString kitSpec = QmakeKitAspect::mkspec(k); QString kitSpec = QmakeKitAspect::mkspec(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k); Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
if (kitSpec.isEmpty() && kitVersion) if (kitSpec.isEmpty() && kitVersion)
kitSpec = kitVersion->mkspecFor(tc); kitSpec = kitVersion->mkspecFor(tc);
QMakeStepConfig::OsType kitOsType = QMakeStepConfig::NoOsType; QMakeStepConfig::OsType kitOsType = QMakeStepConfig::NoOsType;
@@ -241,7 +241,7 @@ Kit *QmakeProjectImporter::createTemporaryKit(const QtProjectImporter::QtVersion
Q_UNUSED(osType) // TODO use this to select the right toolchain? Q_UNUSED(osType) // TODO use this to select the right toolchain?
return QtProjectImporter::createTemporaryKit(data, [&data, parsedSpec](Kit *k) -> void { return QtProjectImporter::createTemporaryKit(data, [&data, parsedSpec](Kit *k) -> void {
for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec)) for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec))
ToolChainKitAspect::setToolChain(k, tc); ToolchainKitAspect::setToolChain(k, tc);
if (parsedSpec != data.qt->mkspec()) if (parsedSpec != data.qt->mkspec())
QmakeKitAspect::setMkspec(k, parsedSpec, QmakeKitAspect::MkspecSource::Code); QmakeKitAspect::setMkspec(k, parsedSpec, QmakeKitAspect::MkspecSource::Code);
}); });

2
src/plugins/qmakeprojectmanager/qmakestep.cpp
View File

@@ -149,7 +149,7 @@ QMakeStepConfig QMakeStep::deducedArguments() const
Kit *kit = target()->kit(); Kit *kit = target()->kit();
QMakeStepConfig config; QMakeStepConfig config;
Abi targetAbi; Abi targetAbi;
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit)) { if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit)) {
targetAbi = tc->targetAbi(); targetAbi = tc->targetAbi();
if (HostOsInfo::isWindowsHost() if (HostOsInfo::isWindowsHost()
&& tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) { && tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) {

8
src/plugins/qnx/qnxsettingspage.cpp
View File

@@ -182,7 +182,7 @@ void QnxConfiguration::deactivate()
for (Kit *kit : kits) { for (Kit *kit : kits) {
if (kit->isAutoDetected() if (kit->isAutoDetected()
&& DeviceTypeKitAspect::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE && DeviceTypeKitAspect::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE
&& toolChainsToRemove.contains(ToolChainKitAspect::cxxToolChain(kit))) { && toolChainsToRemove.contains(ToolchainKitAspect::cxxToolChain(kit))) {
KitManager::deregisterKit(kit); KitManager::deregisterKit(kit);
} }
} }
@@ -258,8 +258,8 @@ void QnxConfiguration::createKit(const QnxTarget &target)
const auto init = [&](Kit *k) { const auto init = [&](Kit *k) {
QtKitAspect::setQtVersion(k, qnxQt); QtKitAspect::setQtVersion(k, qnxQt);
ToolChainKitAspect::setToolChain(k, toolChains[0]); ToolchainKitAspect::setToolChain(k, toolChains[0]);
ToolChainKitAspect::setToolChain(k, toolChains[1]); ToolchainKitAspect::setToolChain(k, toolChains[1]);
if (debugger.isValid()) if (debugger.isValid())
DebuggerKitAspect::setDebugger(k, debugger); DebuggerKitAspect::setDebugger(k, debugger);
@@ -275,7 +275,7 @@ void QnxConfiguration::createKit(const QnxTarget &target)
k->setAutoDetectionSource(m_envFile.toString()); k->setAutoDetectionSource(m_envFile.toString());
k->setMutable(DeviceKitAspect::id(), true); k->setMutable(DeviceKitAspect::id(), true);
k->setSticky(ToolChainKitAspect::id(), true); k->setSticky(ToolchainKitAspect::id(), true);
k->setSticky(DeviceTypeKitAspect::id(), true); k->setSticky(DeviceTypeKitAspect::id(), true);
k->setSticky(SysRootKitAspect::id(), true); k->setSticky(SysRootKitAspect::id(), true);
k->setSticky(DebuggerKitAspect::id(), true); k->setSticky(DebuggerKitAspect::id(), true);

4
src/plugins/qtsupport/baseqtversion.cpp
View File

@@ -542,7 +542,7 @@ Tasks QtVersion::validateKit(const Kit *k)
result << BuildSystemTask(Task::Warning, Tr::tr("Device type is not supported by Qt version.")); result << BuildSystemTask(Task::Warning, Tr::tr("Device type is not supported by Qt version."));
} }
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) { if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
Abi targetAbi = tc->targetAbi(); Abi targetAbi = tc->targetAbi();
Abis supportedAbis = tc->supportedAbis(); Abis supportedAbis = tc->supportedAbis();
bool fuzzyMatch = false; bool fuzzyMatch = false;
@@ -576,7 +576,7 @@ Tasks QtVersion::validateKit(const Kit *k)
version->displayName(), qtAbiString); version->displayName(), qtAbiString);
result << BuildSystemTask(fuzzyMatch ? Task::Warning : Task::Error, message); result << BuildSystemTask(fuzzyMatch ? Task::Warning : Task::Error, message);
} }
} else if (ToolChainKitAspect::cToolChain(k)) { } else if (ToolchainKitAspect::cToolChain(k)) {
const QString message = Tr::tr("The kit has a Qt version, but no C++ compiler."); const QString message = Tr::tr("The kit has a Qt version, but no C++ compiler.");
result << BuildSystemTask(Task::Warning, message); result << BuildSystemTask(Task::Warning, message);
} }

10
src/plugins/qtsupport/qtkitaspect.cpp
View File

@@ -175,7 +175,7 @@ void QtKitAspectFactory::setup(Kit *k)
{ {
if (!k || k->hasValue(id())) if (!k || k->hasValue(id()))
return; return;
const Abi tcAbi = ToolChainKitAspect::targetAbi(k); const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
const Id deviceType = DeviceTypeKitAspect::deviceTypeId(k); const Id deviceType = DeviceTypeKitAspect::deviceTypeId(k);
const QtVersions matches const QtVersions matches
@@ -226,7 +226,7 @@ void QtKitAspectFactory::fix(Kit *k)
} }
// Set a matching toolchain if we don't have one. // Set a matching toolchain if we don't have one.
if (ToolChainKitAspect::cxxToolChain(k)) if (ToolchainKitAspect::cxxToolChain(k))
return; return;
const QString spec = version->mkspec(); const QString spec = version->mkspec();
@@ -283,7 +283,7 @@ void QtKitAspectFactory::fix(Kit *k)
}); });
if (Toolchain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first()) if (Toolchain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
ToolChainKitAspect::setAllToolChainsToMatch(k, bestTc); ToolchainKitAspect::setAllToolChainsToMatch(k, bestTc);
} }
} }
@@ -405,7 +405,7 @@ void QtKitAspect::setQtVersion(Kit *k, const QtVersion *v)
void QtKitAspect::addHostBinariesToPath(const Kit *k, Environment &env) void QtKitAspect::addHostBinariesToPath(const Kit *k, Environment &env)
{ {
if (const Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) if (const Toolchain *tc = ToolchainKitAspect::cxxToolChain(k))
env.prependOrSetPath(tc->compilerCommand().parentDir()); env.prependOrSetPath(tc->compilerCommand().parentDir());
if (const QtVersion *qt = qtVersion(k)) if (const QtVersion *qt = qtVersion(k))
@@ -479,7 +479,7 @@ int QtKitAspectFactory::weight(const Kit *k) const
return 0; return 0;
if (!qt->targetDeviceTypes().contains(DeviceTypeKitAspect::deviceTypeId(k))) if (!qt->targetDeviceTypes().contains(DeviceTypeKitAspect::deviceTypeId(k)))
return 0; return 0;
const Abi tcAbi = ToolChainKitAspect::targetAbi(k); const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
if (qt->qtAbis().contains(tcAbi)) if (qt->qtAbis().contains(tcAbi))
return 2; return 2;
return Utils::contains(qt->qtAbis(), [&tcAbi](const Abi &qtAbi) { return Utils::contains(qt->qtAbis(), [&tcAbi](const Abi &qtAbi) {

2
src/plugins/valgrind/memchecktool.cpp
View File

@@ -714,7 +714,7 @@ void MemcheckToolPrivate::heobAction()
if (RunConfiguration *rc = target->activeRunConfiguration()) { if (RunConfiguration *rc = target->activeRunConfiguration()) {
kit = target->kit(); kit = target->kit();
if (kit) { if (kit) {
abi = ToolChainKitAspect::targetAbi(kit); abi = ToolchainKitAspect::targetAbi(kit);
sr = rc->runnable(); sr = rc->runnable();
const IDevice::ConstPtr device const IDevice::ConstPtr device
= DeviceManager::deviceForPath(sr.command.executable()); = DeviceManager::deviceForPath(sr.command.executable());