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))
return false;
return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
ToolChainKitAspect::cxxToolChain(b))
ToolchainKitAspect::cxxToolChain(b))
&& matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
ToolChainKitAspect::cToolChain(b));
ToolchainKitAspect::cToolChain(b));
});
const auto initializeKit = [allLanguages, tc, qt](Kit *k) {
@@ -1397,7 +1397,7 @@ void AndroidConfigurations::updateAutomaticKitList()
k->setAutoDetectionSource("AndroidConfiguration");
DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE);
for (Toolchain *tc : allLanguages)
ToolChainKitAspect::setToolChain(k, tc);
ToolchainKitAspect::setToolChain(k, tc);
QtKitAspect::setQtVersion(k, qt);
QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis();
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)
return {};
auto tc = ToolChainKitAspect::cxxToolChain(target->kit());
auto tc = ToolchainKitAspect::cxxToolChain(target->kit());
if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_TYPEID)
return {};
QJsonObject settings;

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

@@ -73,7 +73,7 @@ bool AndroidPackageInstallationStep::init()
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.")
.arg(displayName()), Task::TaskType::Error);
return false);

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

@@ -59,7 +59,7 @@ void AutoTestUnitTests::initTestCase()
m_isQt4 = qtVersion->qtVersionString().startsWith('4');
else
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)
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;
}
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(m_kit);
if (!toolchain) {
qWarning() << "This test requires that there is a kit with a toolchain.";
return false;

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

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

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

@@ -148,7 +148,7 @@ static QList<Target *> validTargets(Project *project)
return false;
}
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(kit);
const Toolchain * const toolchain = ToolchainKitAspect::cxxToolChain(kit);
QTC_ASSERT(toolchain, return false);
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)
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)
QSKIP("This test requires that there is a kit with a toolchain.");
@@ -87,7 +87,7 @@ void ClangToolsUnitTests::testProject()
QFETCH(int, expectedDiagCountClazy);
QFETCH(ClangDiagnosticConfig, diagnosticConfig);
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)
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)
{
Toolchain *toolchain = ToolChainKitAspect::cxxToolChain(k);
Toolchain *toolchain = ToolchainKitAspect::cxxToolChain(k);
if (!toolchain)
return false;
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();
if (!sysRoot.isEmpty()) {
cmd.addArg("-DCMAKE_SYSROOT:PATH=" + sysRoot);
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) {
if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
const QString targetTriple = tc->originalTargetTriple();
cmd.addArg("-DCMAKE_C_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);
cmakeParser->setSourceDirectory(project()->projectDirectory());
formatter->addLineParsers({cmakeParser, new GnuMakeParser});
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit());
Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
OutputTaskParser *xcodeBuildParser = nullptr;
if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
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) {
// *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) {
it = std::find_if(known.constBegin(),
known.constEnd(),
@@ -1135,8 +1135,8 @@ Tasks CMakeConfigurationKitAspectFactory::validate(const Kit *k) const
return Tasks();
const QtSupport::QtVersion *const version = QtSupport::QtKitAspect::qtVersion(k);
const Toolchain *const tcC = ToolChainKitAspect::cToolChain(k);
const Toolchain *const tcCxx = ToolChainKitAspect::cxxToolChain(k);
const Toolchain *const tcC = ToolchainKitAspect::cToolChain(k);
const Toolchain *const tcCxx = ToolchainKitAspect::cxxToolChain(k);
const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
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))
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(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,
[&tcd](const Id &language) { return language == tcd.language; }))
continue;
Toolchain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
Toolchain *tc = ToolchainKitAspect::toolChain(k, tcd.language);
if ((!tc || !tc->matchesCompilerCommand(tcd.compilerPath))) {
return false;
}
@@ -950,7 +950,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; }))
continue;
Toolchain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
Toolchain *tc = ToolchainKitAspect::toolChain(k, tcd.language);
if (tc && tc->matchesCompilerCommand(tcd.compilerPath)) {
return false;
}
@@ -1001,10 +1001,10 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
if (tcd.areTemporary) {
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()) {

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

@@ -407,8 +407,8 @@ void CMakeManager::buildFile(Node *node)
return extension;
const auto toolchain = ProjectFile::isCxx(sourceKind)
? ToolChainKitAspect::cxxToolChain(target->kit())
: ToolChainKitAspect::cToolChain(target->kit());
? ToolchainKitAspect::cxxToolChain(target->kit())
: ToolchainKitAspect::cToolChain(target->kit());
using namespace ProjectExplorer::Constants;
static QSet<Id> objIds{
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)
{
if (flags.empty())
return ToolChainKitAspect::toolChain(kit, language);
return ToolchainKitAspect::toolChain(kit, language);
// Try exact compiler match.
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;
}
toolchain = ToolChainKitAspect::toolChain(kit, language);
toolchain = ToolchainKitAspect::toolChain(kit, language);
qWarning() << "No matching toolchain found, use the default.";
return toolchain;
}

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

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

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

@@ -135,7 +135,7 @@ void CppcheckPluginPrivate::updateManualRunAction()
const Target *target = ProjectManager::startupTarget();
const Utils::Id cxx = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
const bool canRun = target && project->projectLanguages().contains(cxx)
&& ToolChainKitAspect::cxxToolChain(target->kit());
&& ToolchainKitAspect::cxxToolChain(target->kit());
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 ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString()));
if (classifier.isC()) {
tc = ToolChainKitAspect::cToolChain(project->activeTarget()->kit());
tc = ToolchainKitAspect::cToolChain(project->activeTarget()->kit());
} else if (classifier.isCxx() || classifier.isHeader()) {
tc = ToolChainKitAspect::cxxToolChain(project->activeTarget()->kit());
tc = ToolchainKitAspect::cxxToolChain(project->activeTarget()->kit());
} else {
showFallbackWarning(Tr::tr("Could not determine which compiler to invoke."));
useBuiltinPreprocessor();
@@ -1965,7 +1965,7 @@ void CppModelManager::setupFallbackProjectPart()
// TODO: Use different fallback toolchain for different kinds of files?
const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr;
const Toolchain * const defaultTc = defaultKit
? ToolChainKitAspect::cxxToolChain(defaultKit) : nullptr;
? ToolchainKitAspect::cxxToolChain(defaultKit) : nullptr;
if (defaultKit && defaultTc) {
FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
if (sysroot.isEmpty())

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

@@ -148,7 +148,7 @@ DebuggerKitAspect::ConfigurationErrors DebuggerKitAspect::configurationErrors(co
if (!debugger.isExecutableFile())
result |= DebuggerNotExecutable;
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
if (item->matchTarget(tcAbi) == DebuggerItem::DoesNotMatch) {
// currently restricting the check to desktop devices, may be extended to all device types
const IDevice::ConstPtr device = DeviceKitAspect::device(k);
@@ -303,7 +303,7 @@ public:
// </valuemap>
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.
// 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;
}
if (wordWidth)
return ToolChainKitAspect::targetAbi(k).wordWidth() == wordWidth;
return ToolchainKitAspect::targetAbi(k).wordWidth() == wordWidth;
return true;
};
}
@@ -1308,13 +1308,13 @@ static Kit *guessKitFromAbis(const Abis &abis)
if (!abis.isEmpty()) {
// Try exact abis.
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);
});
if (!kit) {
// Or something compatible.
kit = KitManager::kit([abis](const Kit *k) {
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
return !DebuggerKitAspect::configurationErrors(k)
&& Utils::contains(abis, [tcAbi](const Abi &a) { return a.isCompatibleWith(tcAbi); });
});
@@ -1764,7 +1764,7 @@ RunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
return nullptr;
}
const Abi tcAbi = ToolChainKitAspect::targetAbi(kit);
const Abi tcAbi = ToolchainKitAspect::targetAbi(kit);
const bool isWindows = (tcAbi.os() == Abi::WindowsOS);
if (isWindows && isWinProcessBeingDebugged(processInfo.processId)) {
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.toolChainAbi = ToolChainKitAspect::targetAbi(kit);
m_runParameters.toolChainAbi = ToolchainKitAspect::targetAbi(kit);
bool ok = false;
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->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->populate();

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

@@ -364,12 +364,12 @@ void KitDetectorPrivate::autoDetect()
&& (!qt || qt->qtAbis().contains(tc->targetAbi()));
});
for (Toolchain *toolChain : toolchainsToSet)
ToolChainKitAspect::setToolChain(k, toolChain);
ToolchainKitAspect::setToolChain(k, toolChain);
if (cmakeId.isValid())
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(DeviceKitAspect::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 (Target *target = buildStep()->target()) {
if (Toolchain *toolChain = ToolChainKitAspect::cxxToolChain(target->kit()))
if (Toolchain *toolChain = ToolchainKitAspect::cxxToolChain(target->kit()))
return toolChain->makeCommand(buildConfig->environment());
}
}

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

@@ -148,7 +148,7 @@ bool IosBuildStep::init()
if (!AbstractProcessStep::init())
return false;
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit());
Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit());
if (!tc) {
emit addTask(Task::compilerMissingTask());
emitFaultyConfigurationMessage();
@@ -195,7 +195,7 @@ QStringList IosBuildStep::defaultArguments() const
{
QStringList res;
Kit *kit = target()->kit();
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit);
Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
switch (buildConfiguration()->buildType()) {
case BuildConfiguration::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);
if (toolChains.first)
ToolChainKitAspect::setToolChain(kit, toolChains.first);
ToolchainKitAspect::setToolChain(kit, toolChains.first);
else
ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
if (toolChains.second)
ToolChainKitAspect::setToolChain(kit, toolChains.second);
ToolchainKitAspect::setToolChain(kit, toolChains.second);
else
ToolChainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
ToolchainKitAspect::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QtKitAspect::setQtVersion(kit, qtVersion);
// 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->setSticky(QtKitAspect::id(), true);
kit->setSticky(ToolChainKitAspect::id(), true);
kit->setSticky(ToolchainKitAspect::id(), true);
kit->setSticky(DeviceTypeKitAspect::id(), true);
kit->setSticky(SysRootKitAspect::id(), true);
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
// new Xcode is used). Change?
return DeviceTypeKitAspect::deviceTypeId(kit) == pDeviceType
&& ToolChainKitAspect::cxxToolChain(kit) == platformToolchains.second
&& ToolChainKitAspect::cToolChain(kit) == platformToolchains.first
&& ToolchainKitAspect::cxxToolChain(kit) == platformToolchains.second
&& ToolchainKitAspect::cToolChain(kit) == platformToolchains.first
&& QtKitAspect::qtVersion(kit) == qtVersion;
});
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::MinGW:
case McuToolChainPackage::ToolChainType::ArmGcc:
ToolChainKitAspect::setToolChain(k,
ToolchainKitAspect::setToolChain(k,
tcPackage->toolChain(
ProjectExplorer::Constants::C_LANGUAGE_ID));
ToolChainKitAspect::setToolChain(k,
ToolchainKitAspect::setToolChain(k,
tcPackage->toolChain(
ProjectExplorer::Constants::CXX_LANGUAGE_ID));
return;

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

@@ -39,7 +39,7 @@ Tasks MesonProject::projectIssues(const Kit *k) const
if (!NinjaToolKitAspect::isValid(k))
result.append(
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,
Tr::tr("No compilers set in kit.")));
return result;

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

@@ -169,7 +169,7 @@ void NimBuildSystem::triggerParsing()
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 {});
const FilePath command = tc->compilerCommand();
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());
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 {});
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 result = Project::projectIssues(k);
auto tc = ToolChainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID);
auto tc = ToolchainKitAspect::toolChain(k, Constants::C_NIMLANGUAGE_ID);
if (!tc) {
result.append(createProjectTask(Task::TaskType::Error, Tr::tr("No Nim compiler set.")));
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':'));
}
if (auto toolChain = ToolChainKitAspect::cxxToolChain(kit)) {
if (auto toolChain = ToolchainKitAspect::cxxToolChain(kit)) {
Abi::Architecture architecture = toolChain->targetAbi().architecture();
if (architecture == Abi::ArmArchitecture && toolChain->targetAbi().wordWidth() == 64) {
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())
return FilePath::fromSettings(k->value(SysRootKitAspect::id()));
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) {
for (Toolchain *tc : ToolchainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty())
return FilePath::fromString(tc->sysRoot());
}
@@ -172,7 +172,7 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
if (!k)
return;
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) {
for (Toolchain *tc : ToolchainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty()) {
// It's the sysroot from toolchain, don't set it.
if (tc->sysRoot() == v.toString())
@@ -188,14 +188,14 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
const SysRootKitAspectFactory theSyRootKitAspectFactory;
// --------------------------------------------------------------------------
// ToolChainKitAspect:
// ToolchainKitAspect:
// --------------------------------------------------------------------------
namespace Internal {
class ToolChainKitAspectImpl final : public KitAspect
class ToolchainKitAspectImpl final : public KitAspect
{
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->setContentsMargins(0, 0, 0, 0);
@@ -230,7 +230,7 @@ public:
setManagingPage(Constants::TOOLCHAIN_SETTINGS_PAGE_ID);
}
~ToolChainKitAspectImpl() override
~ToolchainKitAspectImpl() override
{
delete m_mainWidget;
}
@@ -272,7 +272,7 @@ private:
cb->addItem(item->displayName(), item->id());
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);
}
}
@@ -295,9 +295,9 @@ private:
Toolchain *tc = ToolChainManager::findToolChain(id);
QTC_ASSERT(!tc || tc->language() == language, return);
if (tc)
ToolChainKitAspect::setToolChain(m_kit, tc);
ToolchainKitAspect::setToolChain(m_kit, tc);
else
ToolChainKitAspect::clearToolChain(m_kit, language);
ToolchainKitAspect::clearToolChain(m_kit, language);
}
int indexOf(QComboBox *cb, const Toolchain *tc)
@@ -317,10 +317,10 @@ private:
};
} // namespace Internal
class ToolChainKitAspectFactory : public KitAspectFactory
class ToolchainKitAspectFactory : public KitAspectFactory
{
public:
ToolChainKitAspectFactory();
ToolchainKitAspectFactory();
private:
Tasks validate(const Kit *k) const override;
@@ -346,9 +346,9 @@ private:
void toolChainRemoved(Toolchain *tc);
};
ToolChainKitAspectFactory::ToolChainKitAspectFactory()
ToolchainKitAspectFactory::ToolchainKitAspectFactory()
{
setId(ToolChainKitAspect::id());
setId(ToolchainKitAspect::id());
setDisplayName(Tr::tr("Compiler"));
setDescription(Tr::tr("The compiler to use for building.<br>"
"Make sure the compiler will produce binaries compatible "
@@ -380,13 +380,13 @@ static Store defaultToolChainValue()
return result;
}
Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
Tasks ToolchainKitAspectFactory::validate(const Kit *k) const
{
Tasks result;
const QList<Toolchain*> tcList = ToolChainKitAspect::toolChains(k);
const QList<Toolchain*> tcList = ToolchainKitAspect::toolChains(k);
if (tcList.isEmpty()) {
result << BuildSystemTask(Task::Warning, ToolChainKitAspect::msgNoToolChainInTarget());
result << BuildSystemTask(Task::Warning, ToolchainKitAspect::msgNoToolChainInTarget());
} else {
QSet<Abi> targetAbis;
for (const Toolchain *tc : tcList) {
@@ -402,17 +402,17 @@ Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
return result;
}
void ToolChainKitAspectFactory::fix(Kit *k)
void ToolchainKitAspectFactory::fix(Kit *k)
{
QTC_ASSERT(ToolChainManager::isLoaded(), return);
const QList<Id> languages = ToolChainManager::allLanguages();
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)) {
qWarning("Tool chain set up in kit \"%s\" for \"%s\" not found.",
qPrintable(k->displayName()),
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(); });
}
void ToolChainKitAspectFactory::setup(Kit *k)
void ToolchainKitAspectFactory::setup(Kit *k)
{
QTC_ASSERT(ToolChainManager::isLoaded(), return);
QTC_ASSERT(k, return);
@@ -459,123 +459,123 @@ void ToolChainKitAspectFactory::setup(Kit *k)
bestTc = tc;
}
if (bestTc)
ToolChainKitAspect::setToolChain(k, bestTc);
ToolchainKitAspect::setToolChain(k, bestTc);
else
ToolChainKitAspect::clearToolChain(k, l);
ToolchainKitAspect::clearToolChain(k, l);
}
k->setSticky(id(), lockToolchains);
}
KitAspect *ToolChainKitAspectFactory::createKitAspect(Kit *k) const
KitAspect *ToolchainKitAspectFactory::createKitAspect(Kit *k) const
{
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();
}
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")}};
}
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)
tc->addToEnvironment(env);
}
void ToolChainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expander) const
void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expander) const
{
QTC_ASSERT(kit, return);
// Compatibility with Qt Creator < 4.2:
expander->registerVariable("Compiler:Name", Tr::tr("Compiler"),
[kit] {
const Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit);
const Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
return tc ? tc->displayName() : Tr::tr("None");
});
expander->registerVariable("Compiler:Executable", Tr::tr("Path to the compiler executable"),
[kit] {
const Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit);
const Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit);
return tc ? tc->compilerCommand().path() : QString();
});
// After 4.2
expander->registerPrefix("Compiler:Name", Tr::tr("Compiler for different languages"),
[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");
});
expander->registerPrefix("Compiler:Executable", Tr::tr("Compiler executable for different languages"),
[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();
});
}
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}) {
if (const Toolchain * const tc = ToolChainKitAspect::toolChain(k, langId))
if (const Toolchain * const tc = ToolchainKitAspect::toolChain(k, langId))
return tc->createOutputParsers();
}
return {};
}
QSet<Id> ToolChainKitAspectFactory::availableFeatures(const Kit *k) const
QSet<Id> ToolchainKitAspectFactory::availableFeatures(const Kit *k) const
{
QSet<Id> result;
for (Toolchain *tc : ToolChainKitAspect::toolChains(k))
for (Toolchain *tc : ToolchainKitAspect::toolChains(k))
result.insert(tc->typeId().withPrefix("ToolChain."));
return result;
}
Id ToolChainKitAspect::id()
Id ToolchainKitAspect::id()
{
// "PE.Profile.ToolChain" until 4.2
// "PE.Profile.ToolChains" temporarily before 4.3 (May 2017)
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);
if (!k)
return {};
Store value = storeFromVariant(k->value(ToolChainKitAspect::id()));
Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
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));
}
Toolchain *ToolChainKitAspect::cToolChain(const Kit *k)
Toolchain *ToolchainKitAspect::cToolChain(const Kit *k)
{
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));
}
QList<Toolchain *> ToolChainKitAspect::toolChains(const Kit *k)
QList<Toolchain *> ToolchainKitAspect::toolChains(const Kit *k)
{
QTC_ASSERT(k, return {});
const Store value = storeFromVariant(k->value(ToolChainKitAspect::id()));
const Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
const QList<Toolchain *> tcList
= transform<QList>(ToolChainManager::allLanguages(), [&value](Id l) {
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; });
}
void ToolChainKitAspect::setToolChain(Kit *k, Toolchain *tc)
void ToolchainKitAspect::setToolChain(Kit *k, Toolchain *tc)
{
QTC_ASSERT(tc, 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());
k->setValue(id(), variantFromStore(result));
@@ -603,7 +603,7 @@ void ToolChainKitAspect::setToolChain(Kit *k, Toolchain *tc)
* @param k The kit to set up
* @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(k, return);
@@ -611,7 +611,7 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
const Toolchains allTcList = ToolChainManager::toolchains();
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());
for (const Id l : ToolChainManager::allLanguages()) {
@@ -642,17 +642,17 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
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(k, return);
Store result = storeFromVariant(k->value(ToolChainKitAspect::id()));
Store result = storeFromVariant(k->value(ToolchainKitAspect::id()));
result.insert(language.toKey(), QByteArray());
k->setValue(id(), variantFromStore(result));
}
Abi ToolChainKitAspect::targetAbi(const Kit *k)
Abi ToolchainKitAspect::targetAbi(const Kit *k)
{
const QList<Toolchain *> tcList = toolChains(k);
// 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...
}
QString ToolChainKitAspect::msgNoToolChainInTarget()
QString ToolchainKitAspect::msgNoToolChainInTarget()
{
return Tr::tr("No compiler set in kit.");
}
void ToolChainKitAspectFactory::onKitsLoaded()
void ToolchainKitAspectFactory::onKitsLoaded()
{
for (Kit *k : KitManager::kits())
fix(k);
connect(ToolChainManager::instance(), &ToolChainManager::toolChainRemoved,
this, &ToolChainKitAspectFactory::toolChainRemoved);
this, &ToolchainKitAspectFactory::toolChainRemoved);
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()) {
if (ToolChainKitAspect::toolChain(k, tc->language()) == tc)
if (ToolchainKitAspect::toolChain(k, tc->language()) == tc)
notifyAboutUpdate(k);
}
}
void ToolChainKitAspectFactory::toolChainRemoved(Toolchain *tc)
void ToolchainKitAspectFactory::toolChainRemoved(Toolchain *tc)
{
Q_UNUSED(tc)
for (Kit *k : KitManager::kits())
fix(k);
}
const ToolChainKitAspectFactory thsToolChainKitAspectFactory;
const ToolchainKitAspectFactory thsToolChainKitAspectFactory;
// --------------------------------------------------------------------------
// DeviceTypeKitAspect:

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

@@ -26,7 +26,7 @@ public:
// ToolChainKitAspect
class PROJECTEXPLORER_EXPORT ToolChainKitAspect
class PROJECTEXPLORER_EXPORT ToolchainKitAspect
{
public:
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)
{
const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit);
const QList<Toolchain *> toolchains = ToolchainKitAspect::toolChains(kit);
for (const Toolchain * const tc : toolchains) {
const Abi tcAbi = tc->targetAbi();
for (const Abi &abi : abis) {
@@ -183,7 +183,7 @@ static Id deviceTypeForKit(const Kit *kit)
{
if (isHostKit(kit))
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) {
const Abi tcAbi = tc->targetAbi();
switch (tcAbi.os()) {
@@ -347,10 +347,10 @@ void KitManager::restoreKits()
kit->setSdkProvided(false);
kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here?
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) {
return ToolChainKitAspect::toolChains(kit.get())
== ToolChainKitAspect::toolChains(existingKit.get());
return ToolchainKitAspect::toolChains(kit.get())
== ToolchainKitAspect::toolChains(existingKit.get());
})) {
continue;
}

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

@@ -130,7 +130,7 @@ QString MakeStep::defaultDisplayName()
static const QList<Toolchain *> preferredToolChains(const Kit *kit)
{
// 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())
return false;
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.
Kit * const kit = findOr(KitManager::kits(), nullptr, [](const Kit *k) {
return k->isValid() && ToolChainKitAspect::cxxToolChain(k);
return k->isValid() && ToolchainKitAspect::cxxToolChain(k);
});
if (!kit)
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);
if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) {
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)
{
useTemporaryKitAspect(ToolChainKitAspect::id(),
useTemporaryKitAspect(ToolchainKitAspect::id(),
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(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);
QTC_ASSERT(tc, continue);
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) {
Toolchain *tmpTc = toolChainFromVariant(v);
QTC_ASSERT(tmpTc, continue);
Toolchain *actualTc = ToolChainKitAspect::toolChain(k, tmpTc->language());
Toolchain *actualTc = ToolchainKitAspect::toolChain(k, tmpTc->language());
if (tmpTc && actualTc != tmpTc)
ToolChainManager::deregisterToolChain(tmpTc);
}
@@ -394,7 +394,7 @@ ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
});
for (const Toolchain *tc : std::as_const(result.tcs)) {
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())
return result;

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

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

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

@@ -238,8 +238,8 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
if (!sysroot.isEmpty())
data.insert(QLatin1String(QBS_SYSROOT), sysroot);
Toolchain *tcC = ToolChainKitAspect::cToolChain(k);
Toolchain *tcCxx = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tcC = ToolchainKitAspect::cToolChain(k);
Toolchain *tcCxx = ToolchainKitAspect::cxxToolChain(k);
if (!tcC && !tcCxx)
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);
qCDebug(qbsPmLog) << "matching kit" << k->displayName() << "against imported build"
<< bgData->bgFilePath.toUserOutput();
if (ToolChainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
if (ToolchainKitAspect::toolChains(k).isEmpty() && bgData->cCompilerPath.isEmpty()
&& bgData->cxxCompilerPath.isEmpty()) {
return true;
}
const Toolchain * const cToolchain = ToolChainKitAspect::cToolChain(k);
const Toolchain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k);
const Toolchain * const cToolchain = ToolchainKitAspect::cToolChain(k);
const Toolchain * const cxxToolchain = ToolchainKitAspect::cxxToolChain(k);
if (!bgData->cCompilerPath.isEmpty()) {
if (!cToolchain)
return false;
@@ -190,7 +190,7 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
for (const ToolChainData &tc : std::as_const(tcData)) {
if (!tc.tcs.isEmpty())
ToolChainKitAspect::setToolChain(k, tc.tcs.first());
ToolchainKitAspect::setToolChain(k, tc.tcs.first());
}
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_mkspec(QmakeKitAspect::mkspec(k))
{
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
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
return {};
return version->mkspecFor(ToolChainKitAspect::cxxToolChain(k));
return version->mkspecFor(ToolchainKitAspect::cxxToolChain(k));
}
// QmakeKitAspectFactory

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

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

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

@@ -238,7 +238,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
this, [this](Toolchain *tc) {
if (ToolChainKitAspect::cxxToolChain(kit()) == tc)
if (ToolchainKitAspect::cxxToolChain(kit()) == tc)
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.")));
else if (!qtFromKit->isValid())
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.")));
// 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
{
const Toolchain *const toolchain = ToolChainKitAspect::cxxToolChain(kit());
const Toolchain *const toolchain = ToolchainKitAspect::cxxToolChain(kit());
if (!toolchain)
return {};
@@ -1467,14 +1467,14 @@ QString QmakeBuildSystem::deviceRoot() const
void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
{
const BuildConfiguration *bc = buildConfiguration();
testToolChain(ToolChainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
testToolChain(ToolChainKitAspect::cxxToolChain(kit()),
testToolChain(ToolchainKitAspect::cToolChain(kit()), getFullPathOf(pro, Variable::QmakeCc, bc));
testToolChain(ToolchainKitAspect::cxxToolChain(kit()),
getFullPathOf(pro, Variable::QmakeCxx, bc));
}
FilePath QmakeBuildSystem::executableFor(const QmakeProFile *file)
{
const Toolchain *const tc = ToolChainKitAspect::cxxToolChain(kit());
const Toolchain *const tc = ToolchainKitAspect::cxxToolChain(kit());
if (!tc)
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);
QString kitSpec = QmakeKitAspect::mkspec(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
if (kitSpec.isEmpty() && kitVersion)
kitSpec = kitVersion->mkspecFor(tc);
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?
return QtProjectImporter::createTemporaryKit(data, [&data, parsedSpec](Kit *k) -> void {
for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec))
ToolChainKitAspect::setToolChain(k, tc);
ToolchainKitAspect::setToolChain(k, tc);
if (parsedSpec != data.qt->mkspec())
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();
QMakeStepConfig config;
Abi targetAbi;
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit)) {
if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(kit)) {
targetAbi = tc->targetAbi();
if (HostOsInfo::isWindowsHost()
&& 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) {
if (kit->isAutoDetected()
&& DeviceTypeKitAspect::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE
&& toolChainsToRemove.contains(ToolChainKitAspect::cxxToolChain(kit))) {
&& toolChainsToRemove.contains(ToolchainKitAspect::cxxToolChain(kit))) {
KitManager::deregisterKit(kit);
}
}
@@ -258,8 +258,8 @@ void QnxConfiguration::createKit(const QnxTarget &target)
const auto init = [&](Kit *k) {
QtKitAspect::setQtVersion(k, qnxQt);
ToolChainKitAspect::setToolChain(k, toolChains[0]);
ToolChainKitAspect::setToolChain(k, toolChains[1]);
ToolchainKitAspect::setToolChain(k, toolChains[0]);
ToolchainKitAspect::setToolChain(k, toolChains[1]);
if (debugger.isValid())
DebuggerKitAspect::setDebugger(k, debugger);
@@ -275,7 +275,7 @@ void QnxConfiguration::createKit(const QnxTarget &target)
k->setAutoDetectionSource(m_envFile.toString());
k->setMutable(DeviceKitAspect::id(), true);
k->setSticky(ToolChainKitAspect::id(), true);
k->setSticky(ToolchainKitAspect::id(), true);
k->setSticky(DeviceTypeKitAspect::id(), true);
k->setSticky(SysRootKitAspect::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."));
}
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) {
if (Toolchain *tc = ToolchainKitAspect::cxxToolChain(k)) {
Abi targetAbi = tc->targetAbi();
Abis supportedAbis = tc->supportedAbis();
bool fuzzyMatch = false;
@@ -576,7 +576,7 @@ Tasks QtVersion::validateKit(const Kit *k)
version->displayName(), qtAbiString);
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.");
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()))
return;
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
const Id deviceType = DeviceTypeKitAspect::deviceTypeId(k);
const QtVersions matches
@@ -226,7 +226,7 @@ void QtKitAspectFactory::fix(Kit *k)
}
// Set a matching toolchain if we don't have one.
if (ToolChainKitAspect::cxxToolChain(k))
if (ToolchainKitAspect::cxxToolChain(k))
return;
const QString spec = version->mkspec();
@@ -283,7 +283,7 @@ void QtKitAspectFactory::fix(Kit *k)
});
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)
{
if (const Toolchain *tc = ToolChainKitAspect::cxxToolChain(k))
if (const Toolchain *tc = ToolchainKitAspect::cxxToolChain(k))
env.prependOrSetPath(tc->compilerCommand().parentDir());
if (const QtVersion *qt = qtVersion(k))
@@ -479,7 +479,7 @@ int QtKitAspectFactory::weight(const Kit *k) const
return 0;
if (!qt->targetDeviceTypes().contains(DeviceTypeKitAspect::deviceTypeId(k)))
return 0;
const Abi tcAbi = ToolChainKitAspect::targetAbi(k);
const Abi tcAbi = ToolchainKitAspect::targetAbi(k);
if (qt->qtAbis().contains(tcAbi))
return 2;
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()) {
kit = target->kit();
if (kit) {
abi = ToolChainKitAspect::targetAbi(kit);
abi = ToolchainKitAspect::targetAbi(kit);
sr = rc->runnable();
const IDevice::ConstPtr device
= DeviceManager::deviceForPath(sr.command.executable());