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

ProjectExplorer: Some more ToolChain->Toolchain renamings

Browse Source 
Change-Id: I5cb2adf544a846f45f7fe7ce60f67b10ad100d91
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2023-12-11 11:42:00 +01:00
parent a0c05cabcc
commit 27ef041d28
58 changed files with 246 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1124,13 +1124,13 @@ void AndroidConfigurations::setConfig(const AndroidConfig &devConfigs)
m_instance->save();
updateAndroidDevice();
registerNewToolChains();
registerNewToolchains();
updateAutomaticKitList();
removeOldToolChains();
removeOldToolchains();
emit m_instance->updated();
}
static bool matchToolChain(const Toolchain *atc, const Toolchain *btc)
static bool matchToolchain(const Toolchain *atc, const Toolchain *btc)
{
if (atc == btc)
return true;
@@ -1144,21 +1144,21 @@ static bool matchToolChain(const Toolchain *atc, const Toolchain *btc)
return atc->targetAbi() == btc->targetAbi();
}
void AndroidConfigurations::registerNewToolChains()
void AndroidConfigurations::registerNewToolchains()
{
const Toolchains existingAndroidToolChains
const Toolchains existingAndroidToolchains
= ToolchainManager::toolchains(Utils::equal(&Toolchain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
const Toolchains newToolchains = AndroidToolchainFactory::autodetectToolChains(
existingAndroidToolChains);
const Toolchains newToolchains = AndroidToolchainFactory::autodetectToolchains(
existingAndroidToolchains);
for (Toolchain *tc : newToolchains)
ToolchainManager::registerToolchain(tc);
registerCustomToolChainsAndDebuggers();
registerCustomToolchainsAndDebuggers();
}
void AndroidConfigurations::removeOldToolChains()
void AndroidConfigurations::removeOldToolchains()
{
const auto tcs = ToolchainManager::toolchains(Utils::equal(&Toolchain::typeId,
Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
@@ -1246,7 +1246,7 @@ static QVariant findOrRegisterDebugger(Toolchain *tc,
bool customDebugger = false)
{
const auto &currentConfig = AndroidConfigurations::currentConfig();
const FilePath ndk = static_cast<AndroidToolChain *>(tc)->ndkLocation();
const FilePath ndk = static_cast<AndroidToolchain *>(tc)->ndkLocation();
const FilePath lldbCommand = currentConfig.lldbPathFromNdk(ndk);
const Debugger::DebuggerItem *existingLldb = existingDebugger(lldbCommand,
Debugger::LldbEngineType);
@@ -1304,22 +1304,22 @@ static QVariant findOrRegisterDebugger(Toolchain *tc,
return registeredLldb.isNull() ? registeredGdb : registeredLldb;
}
void AndroidConfigurations::registerCustomToolChainsAndDebuggers()
void AndroidConfigurations::registerCustomToolchainsAndDebuggers()
{
const Toolchains existingAndroidToolChains = ToolchainManager::toolchains(
const Toolchains existingAndroidToolchains = ToolchainManager::toolchains(
Utils::equal(&Toolchain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
const FilePaths customNdks = FileUtils::toFilePathList(currentConfig().getCustomNdkList());
const Toolchains customToolchains
= AndroidToolchainFactory::autodetectToolChainsFromNdks(existingAndroidToolChains,
= AndroidToolchainFactory::autodetectToolchainsFromNdks(existingAndroidToolchains,
customNdks,
true);
for (Toolchain *tc : customToolchains) {
ToolchainManager::registerToolchain(tc);
const auto androidToolChain = static_cast<AndroidToolChain *>(tc);
const auto androidToolchain = static_cast<AndroidToolchain *>(tc);
QString abiStr;
if (androidToolChain)
abiStr = androidToolChain->platformLinkerFlags().at(1).split('-').first();
if (androidToolchain)
abiStr = androidToolchain->platformLinkerFlags().at(1).split('-').first();
findOrRegisterDebugger(tc, {abiStr}, true);
}
}
@@ -1369,27 +1369,27 @@ void AndroidConfigurations::updateAutomaticKitList()
continue;
for (const QtVersion *qt : qtVersionsForArch.value(tc->targetAbi())) {
FilePath tcNdk = static_cast<const AndroidToolChain *>(tc)->ndkLocation();
FilePath tcNdk = static_cast<const AndroidToolchain *>(tc)->ndkLocation();
if (tcNdk != currentConfig().ndkLocation(qt))
continue;
const Toolchains allLanguages
= Utils::filtered(toolchains, [tc, tcNdk](Toolchain *otherTc) {
FilePath otherNdk = static_cast<const AndroidToolChain *>(otherTc)->ndkLocation();
FilePath otherNdk = static_cast<const AndroidToolchain *>(otherTc)->ndkLocation();
return tc->targetAbi() == otherTc->targetAbi() && tcNdk == otherNdk;
});
QHash<Id, Toolchain *> toolChainForLanguage;
QHash<Id, Toolchain *> toolchainForLanguage;
for (Toolchain *tc : allLanguages)
toolChainForLanguage[tc->language()] = tc;
toolchainForLanguage[tc->language()] = tc;
Kit *existingKit = Utils::findOrDefault(existingKits, [&](const Kit *b) {
if (qt != QtKitAspect::qtVersion(b))
return false;
return matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
ToolchainKitAspect::cxxToolChain(b))
&& matchToolChain(toolChainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
ToolchainKitAspect::cToolChain(b));
return matchToolchain(toolchainForLanguage[ProjectExplorer::Constants::CXX_LANGUAGE_ID],
ToolchainKitAspect::cxxToolchain(b))
&& matchToolchain(toolchainForLanguage[ProjectExplorer::Constants::C_LANGUAGE_ID],
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));

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

@@ -185,10 +185,10 @@ public:
static void setConfig(const AndroidConfig &config);
static AndroidConfigurations *instance();
static void registerNewToolChains();
static void registerCustomToolChainsAndDebuggers();
static void registerNewToolchains();
static void registerCustomToolchainsAndDebuggers();
static void removeUnusedDebuggers();
static void removeOldToolChains();
static void removeOldToolchains();
static void updateAutomaticKitList();
static bool force32bitEmulator();

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);

4
src/plugins/android/androidplugin.cpp
View File

@@ -132,11 +132,11 @@ void AndroidPlugin::kitsRestored()
&AndroidPlugin::askUserAboutAndroidSetup, Qt::QueuedConnection);
}
AndroidConfigurations::registerNewToolChains();
AndroidConfigurations::registerNewToolchains();
AndroidConfigurations::updateAutomaticKitList();
connect(QtSupport::QtVersionManager::instance(), &QtSupport::QtVersionManager::qtVersionsChanged,
AndroidConfigurations::instance(), [] {
AndroidConfigurations::registerNewToolChains();
AndroidConfigurations::registerNewToolchains();
AndroidConfigurations::updateAutomaticKitList();
});
disconnect(KitManager::instance(), &KitManager::kitsLoaded,

45
src/plugins/android/androidtoolchain.cpp
View File

@@ -34,8 +34,8 @@ Q_GLOBAL_STATIC_WITH_ARGS(ClangTargetsType, ClangTargets, ({
Abi(Abi::ArmArchitecture, Abi::LinuxOS, Abi::AndroidLinuxFlavor, Abi::ElfFormat, 64)}}
));
static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &target,
const ToolChainList &alreadyKnown)
static Toolchain *findToolchain(FilePath &compilerPath, Id lang, const QString &target,
const ToolchainList &alreadyKnown)
{
Toolchain *tc = Utils::findOrDefault(alreadyKnown, [target, compilerPath, lang](Toolchain *tc) {
return tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
@@ -46,25 +46,25 @@ static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &
return tc;
}
AndroidToolChain::AndroidToolChain()
AndroidToolchain::AndroidToolchain()
: GccToolchain(Constants::ANDROID_TOOLCHAIN_TYPEID, Clang)
{
setTypeDisplayName(Tr::tr("Android Clang"));
}
FilePath AndroidToolChain::ndkLocation() const
FilePath AndroidToolchain::ndkLocation() const
{
return m_ndkLocation;
}
void AndroidToolChain::setNdkLocation(const FilePath &ndkLocation)
void AndroidToolchain::setNdkLocation(const FilePath &ndkLocation)
{
m_ndkLocation = ndkLocation;
}
AndroidToolChain::~AndroidToolChain() = default;
AndroidToolchain::~AndroidToolchain() = default;
bool AndroidToolChain::isValid() const
bool AndroidToolchain::isValid() const
{
if (m_ndkLocation.isEmpty()) {
QStringList ndkParts(compilerCommand().toString().split("toolchains/llvm/prebuilt/"));
@@ -85,7 +85,7 @@ bool AndroidToolChain::isValid() const
&& !originalTargetTriple().isEmpty();
}
void AndroidToolChain::addToEnvironment(Environment &env) const
void AndroidToolchain::addToEnvironment(Environment &env) const
{
const AndroidConfig &config = AndroidConfigurations::currentConfig();
env.set(QLatin1String("ANDROID_NDK_HOST"), config.toolchainHostFromNdk(m_ndkLocation));
@@ -102,7 +102,7 @@ void AndroidToolChain::addToEnvironment(Environment &env) const
env.set(QLatin1String("ANDROID_SDK_ROOT"), config.sdkLocation().toUserOutput());
}
void AndroidToolChain::fromMap(const Store &data)
void AndroidToolchain::fromMap(const Store &data)
{
GccToolchain::fromMap(data);
if (hasError())
@@ -111,19 +111,19 @@ void AndroidToolChain::fromMap(const Store &data)
reportError();
}
QStringList AndroidToolChain::suggestedMkspecList() const
QStringList AndroidToolchain::suggestedMkspecList() const
{
return {"android-g++", "android-clang"};
}
FilePath AndroidToolChain::makeCommand(const Environment &env) const
FilePath AndroidToolchain::makeCommand(const Environment &env) const
{
Q_UNUSED(env)
FilePath makePath = AndroidConfigurations::currentConfig().makePathFromNdk(m_ndkLocation);
return makePath.exists() ? makePath : FilePath("make");
}
GccToolchain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
GccToolchain::DetectedAbisResult AndroidToolchain::detectSupportedAbis() const
{
for (auto itr = ClangTargets->constBegin(); itr != ClangTargets->constEnd(); ++itr) {
if (itr.value() == targetAbi())
@@ -132,17 +132,14 @@ GccToolchain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
return GccToolchain::DetectedAbisResult({targetAbi()}, "");
}
// --------------------------------------------------------------------------
// ToolChainFactory
// --------------------------------------------------------------------------
// AndroidToolchainFactory
AndroidToolchainFactory::AndroidToolchainFactory()
{
setDisplayName(Tr::tr("Android Clang"));
setSupportedToolchainType(Constants::ANDROID_TOOLCHAIN_TYPEID);
setSupportedLanguages({ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new AndroidToolChain; });
setToolchainConstructor([] { return new AndroidToolchain; });
}
static FilePath clangPlusPlusPath(const FilePath &clangPath)
@@ -169,14 +166,14 @@ static FilePaths uniqueNdksForCurrentQtVersions()
return uniqueNdks;
}
ToolChainList AndroidToolchainFactory::autodetectToolChains(const ToolChainList &alreadyKnown)
ToolchainList AndroidToolchainFactory::autodetectToolchains(const ToolchainList &alreadyKnown)
{
const QList<FilePath> uniqueNdks = uniqueNdksForCurrentQtVersions();
return autodetectToolChainsFromNdks(alreadyKnown, uniqueNdks);
return autodetectToolchainsFromNdks(alreadyKnown, uniqueNdks);
}
ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
const ToolChainList &alreadyKnown,
ToolchainList AndroidToolchainFactory::autodetectToolchainsFromNdks(
const ToolchainList &alreadyKnown,
const QList<FilePath> &ndkLocations,
const bool isCustom)
{
@@ -211,7 +208,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
while (targetItr != ClangTargets->constEnd()) {
const Abi &abi = targetItr.value();
const QString target = targetItr.key();
Toolchain *tc = findToolChain(compilerCommand, lang, target, alreadyKnown);
Toolchain *tc = findToolchain(compilerCommand, lang, target, alreadyKnown);
QLatin1String customStr = isCustom ? QLatin1String("Custom ") : QLatin1String();
const QString displayName(customStr + QString("Android Clang (%1, %2, NDK %3)")
@@ -225,7 +222,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
} else {
qCDebug(androidTCLog) << "New Clang toolchain found" << abi.toString() << lang
<< "for NDK" << ndkLocation;
auto atc = new AndroidToolChain();
auto atc = new AndroidToolchain();
atc->setNdkLocation(ndkLocation);
atc->setOriginalTargetTriple(target);
atc->setLanguage(lang);
@@ -239,7 +236,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
// Do not only reset newly created toolchains. This triggers call to
// addToEnvironment, so that e.g. JAVA_HOME gets updated.
if (auto gccTc = dynamic_cast<GccToolchain*>(tc))
gccTc->resetToolChain(compilerCommand);
gccTc->resetToolchain(compilerCommand);
tc->setDetection(Toolchain::AutoDetection);
result << tc;

14
src/plugins/android/androidtoolchain.h
View File

@@ -9,12 +9,12 @@
namespace Android::Internal {
using ToolChainList = QList<ProjectExplorer::Toolchain *>;
using ToolchainList = QList<ProjectExplorer::Toolchain *>;
class AndroidToolChain : public ProjectExplorer::GccToolchain
class AndroidToolchain : public ProjectExplorer::GccToolchain
{
public:
~AndroidToolChain() override;
~AndroidToolchain() override;
bool isValid() const override;
void addToEnvironment(Utils::Environment &env) const override;
@@ -30,7 +30,7 @@ protected:
DetectedAbisResult detectSupportedAbis() const override;
private:
explicit AndroidToolChain();
explicit AndroidToolchain();
friend class AndroidToolchainFactory;
@@ -42,7 +42,7 @@ class AndroidToolchainFactory : public ProjectExplorer::ToolchainFactory
public:
AndroidToolchainFactory();
class AndroidToolChainInformation
class AndroidToolchainInformation
{
public:
Utils::Id language;
@@ -51,8 +51,8 @@ public:
QString version;
};
static ToolChainList autodetectToolChains(const ToolChainList &alreadyKnown);
static ToolChainList autodetectToolChainsFromNdks(const ToolChainList &alreadyKnown,
static ToolchainList autodetectToolchains(const ToolchainList &alreadyKnown);
static ToolchainList autodetectToolchainsFromNdks(const ToolchainList &alreadyKnown,
const QList<Utils::FilePath> &ndkLocations,
const bool isCustom = 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;

4
src/plugins/autotoolsprojectmanager/autotoolsbuildsystem.cpp
View File

@@ -144,8 +144,8 @@ void AutotoolsBuildSystem::updateCppCodeModel()
cxxflags = cflags;
const FilePath includeFileBaseDir = projectDirectory();
rpp.setFlagsForC({kitInfo.cToolChain, cflags, includeFileBaseDir});
rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxflags, includeFileBaseDir});
rpp.setFlagsForC({kitInfo.cToolchain, cflags, includeFileBaseDir});
rpp.setFlagsForCxx({kitInfo.cxxToolchain, cxxflags, includeFileBaseDir});
const QString absSrc = project()->projectDirectory().toString();
BuildConfiguration *bc = target()->activeBuildConfiguration();

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

@@ -336,7 +336,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;

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

@@ -1351,10 +1351,10 @@ void CMakeBuildSystem::updateProjectData()
addTargetFlagForIos(cFlags, cxxFlags, this, [this] {
return m_configurationFromCMake.stringValueOf("CMAKE_OSX_DEPLOYMENT_TARGET");
});
if (kitInfo.cxxToolChain)
rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxFlags, includeFileBaseDir});
if (kitInfo.cToolChain)
rpp.setFlagsForC({kitInfo.cToolChain, cFlags, includeFileBaseDir});
if (kitInfo.cxxToolchain)
rpp.setFlagsForCxx({kitInfo.cxxToolchain, cxxFlags, includeFileBaseDir});
if (kitInfo.cToolchain)
rpp.setFlagsForC({kitInfo.cToolchain, cFlags, includeFileBaseDir});
}
m_cppCodeModelUpdater->update({p, kitInfo, buildConfiguration()->environment(), rpps},

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);

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

@@ -56,7 +56,7 @@ struct DirectoryData
QString toolset;
FilePath sysroot;
QtProjectImporter::QtVersionData qt;
QVector<ToolchainDescription> toolChains;
QVector<ToolchainDescription> toolchains;
};
static FilePaths scanDirectory(const FilePath &path, const QString &prefix)
@@ -464,7 +464,7 @@ static QMakeAndCMakePrefixPath qtInfoFromCMakeCache(const CMakeConfig &config,
return {qmakeLocation, resultedPrefixPath};
}
static QVector<ToolchainDescription> extractToolChainsFromCache(const CMakeConfig &config)
static QVector<ToolchainDescription> extractToolchainsFromCache(const CMakeConfig &config)
{
QVector<ToolchainDescription> result;
bool haveCCxxCompiler = false;
@@ -563,7 +563,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
return ci.key == key;
});
auto tcd = Utils::findOrDefault(data->toolChains,
auto tcd = Utils::findOrDefault(data->toolchains,
[&language](const ToolchainDescription &t) {
return t.language == language;
});
@@ -790,8 +790,8 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
CMakeConfigItem::PATH,
cmakePrefixPath.toUtf8());
// ToolChains:
data->toolChains = extractToolChainsFromCache(config);
// Toolchains:
data->toolchains = extractToolchainsFromCache(config);
// Update QT_QMAKE_EXECUTABLE and CMAKE_C|XX_COMPILER config values
updateConfigWithDirectoryData(config, data);
@@ -888,8 +888,8 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
if (!qmake.isEmpty())
data->qt = findOrCreateQtVersion(qmake);
// ToolChains:
data->toolChains = extractToolChainsFromCache(config);
// Toolchains:
data->toolchains = extractToolchainsFromCache(config);
qCInfo(cmInputLog) << "Offering to import" << importPath.toUserOutput();
result.push_back(static_cast<void *>(data.release()));
@@ -933,11 +933,11 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
const bool compilersMatch = [k, data] {
const QList<Id> allLanguages = ToolchainManager::allLanguages();
for (const ToolchainDescription &tcd : data->toolChains) {
for (const ToolchainDescription &tcd : data->toolchains) {
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;
}
@@ -946,11 +946,11 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
}();
const bool noCompilers = [k, data] {
const QList<Id> allLanguages = ToolchainManager::allLanguages();
for (const ToolchainDescription &tcd : data->toolChains) {
for (const ToolchainDescription &tcd : data->toolchains) {
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;
}
@@ -995,7 +995,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, data->sysroot);
for (const ToolchainDescription &cmtcd : data->toolChains) {
for (const ToolchainDescription &cmtcd : data->toolchains) {
const ToolChainData tcd = findOrCreateToolChains(cmtcd);
QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
@@ -1004,7 +1004,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
addTemporaryData(ToolchainKitAspect::id(), tc->id(), k);
}
ToolchainKitAspect::setToolChain(k, tcd.tcs.at(0));
ToolchainKitAspect::setToolchain(k, tcd.tcs.at(0));
}
if (!data->cmakePresetDisplayname.isEmpty()) {
@@ -1143,11 +1143,11 @@ void CMakeProjectPlugin::testCMakeProjectImporterQt()
Environment::systemEnvironment());
QCOMPARE(realQmake.path(), expectedQmake);
}
void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
void CMakeProjectPlugin::testCMakeProjectImporterToolchain_data()
{
QTest::addColumn<QStringList>("cache");
QTest::addColumn<QByteArrayList>("expectedLanguages");
QTest::addColumn<QStringList>("expectedToolChains");
QTest::addColumn<QStringList>("expectedToolchains");
QTest::newRow("Empty input")
<< QStringList() << QByteArrayList() << QStringList();
@@ -1180,13 +1180,13 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
<< QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
}
void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
void CMakeProjectPlugin::testCMakeProjectImporterToolchain()
{
QFETCH(QStringList, cache);
QFETCH(QByteArrayList, expectedLanguages);
QFETCH(QStringList, expectedToolChains);
QFETCH(QStringList, expectedToolchains);
QCOMPARE(expectedLanguages.count(), expectedToolChains.count());
QCOMPARE(expectedLanguages.count(), expectedToolchains.count());
CMakeConfig config;
for (const QString &c : std::as_const(cache)) {
@@ -1197,11 +1197,11 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
}
const QVector<ToolchainDescription> tcs = extractToolChainsFromCache(config);
const QVector<ToolchainDescription> tcs = extractToolchainsFromCache(config);
QCOMPARE(tcs.count(), expectedLanguages.count());
for (int i = 0; i < tcs.count(); ++i) {
QCOMPARE(tcs.at(i).language, expectedLanguages.at(i));
QCOMPARE(tcs.at(i).compilerPath.toString(), expectedToolChains.at(i));
QCOMPARE(tcs.at(i).compilerPath.toString(), expectedToolchains.at(i));
}
}

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/cmakeprojectmanager/cmakeprojectplugin.h
View File

@@ -28,8 +28,8 @@ private slots:
void testCMakeProjectImporterQt_data();
void testCMakeProjectImporterQt();
void testCMakeProjectImporterToolChain_data();
void testCMakeProjectImporterToolChain();
void testCMakeProjectImporterToolchain_data();
void testCMakeProjectImporterToolchain();
#endif
private:

24
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;
}
@@ -179,21 +179,21 @@ RawProjectPart makeRawProjectPart(const Utils::FilePath &projectFile,
if (fileKind == CppEditor::ProjectFile::Kind::CHeader
|| fileKind == CppEditor::ProjectFile::Kind::CSource) {
if (!kitInfo.cToolChain) {
kitInfo.cToolChain = toolchainFromFlags(kit,
if (!kitInfo.cToolchain) {
kitInfo.cToolchain = toolchainFromFlags(kit,
originalFlags,
ProjectExplorer::Constants::C_LANGUAGE_ID);
}
addDriverModeFlagIfNeeded(kitInfo.cToolChain, flags, originalFlags);
rpp.setFlagsForC({kitInfo.cToolChain, flags, workingDir});
addDriverModeFlagIfNeeded(kitInfo.cToolchain, flags, originalFlags);
rpp.setFlagsForC({kitInfo.cToolchain, flags, workingDir});
} else {
if (!kitInfo.cxxToolChain) {
kitInfo.cxxToolChain = toolchainFromFlags(kit,
if (!kitInfo.cxxToolchain) {
kitInfo.cxxToolchain = toolchainFromFlags(kit,
originalFlags,
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
}
addDriverModeFlagIfNeeded(kitInfo.cxxToolChain, flags, originalFlags);
rpp.setFlagsForCxx({kitInfo.cxxToolChain, flags, workingDir});
addDriverModeFlagIfNeeded(kitInfo.cxxToolchain, flags, originalFlags);
rpp.setFlagsForCxx({kitInfo.cxxToolchain, flags, workingDir});
}
return rpp;
@@ -350,8 +350,8 @@ void CompilationDatabaseBuildSystem::buildTreeAndProjectParts()
ProjectExplorer::KitInfo kitInfo(k);
QTC_ASSERT(kitInfo.isValid(), return);
// Reset toolchains to pick them based on the database entries.
kitInfo.cToolChain = nullptr;
kitInfo.cxxToolChain = nullptr;
kitInfo.cToolchain = nullptr;
kitInfo.cxxToolchain = nullptr;
RawProjectParts rpps;
QTC_ASSERT(m_parser, return);

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

@@ -106,7 +106,7 @@ ConanInstallStep::ConanInstallStep(BuildStepList *bsl, Id id)
setSummaryUpdater([this]() -> QString {
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());

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();
@@ -1968,7 +1968,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())

8
src/plugins/cppeditor/cppprojectinfogenerator.cpp
View File

@@ -66,7 +66,7 @@ const QVector<ProjectPart::ConstPtr> ProjectInfoGenerator::createProjectParts(
if (!cat.hasParts())
return result;
if (m_projectUpdateInfo.cxxToolChainInfo.isValid()) {
if (m_projectUpdateInfo.cxxToolchainInfo.isValid()) {
if (cat.hasCxxSources()) {
result << createProjectPart(projectFilePath,
rawProjectPart,
@@ -87,7 +87,7 @@ const QVector<ProjectPart::ConstPtr> ProjectInfoGenerator::createProjectParts(
m_cxxToolchainMissing = true;
}
if (m_projectUpdateInfo.cToolChainInfo.isValid()) {
if (m_projectUpdateInfo.cToolchainInfo.isValid()) {
if (cat.hasCSources()) {
result << createProjectPart(projectFilePath,
rawProjectPart,
@@ -124,12 +124,12 @@ ProjectPart::ConstPtr ProjectInfoGenerator::createProjectPart(
ToolChainInfo tcInfo;
if (language == Language::C) {
flags = rawProjectPart.flagsForC;
tcInfo = m_projectUpdateInfo.cToolChainInfo;
tcInfo = m_projectUpdateInfo.cToolchainInfo;
}
// Use Cxx toolchain for C projects without C compiler in kit and for C++ code
if (!tcInfo.isValid()) {
flags = rawProjectPart.flagsForCxx;
tcInfo = m_projectUpdateInfo.cxxToolChainInfo;
tcInfo = m_projectUpdateInfo.cxxToolchainInfo;
}
QString explicitTarget;

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

@@ -356,8 +356,8 @@ public:
ProjectInfoGeneratorTestHelper()
{
TestToolchain aToolChain;
projectUpdateInfo.cxxToolChainInfo = {&aToolChain, {}, {}};
projectUpdateInfo.cToolChainInfo = {&aToolChain, {}, {}};
projectUpdateInfo.cxxToolchainInfo = {&aToolChain, {}, {}};
projectUpdateInfo.cToolchainInfo = {&aToolChain, {}, {}};
}
ProjectInfo::ConstPtr generate()
@@ -426,7 +426,7 @@ void ProjectInfoGeneratorTest::testProjectPartHasLatestLanguageVersionByDefault(
void ProjectInfoGeneratorTest::testUseMacroInspectionReportForLanguageVersion()
{
ProjectInfoGeneratorTestHelper t;
t.projectUpdateInfo.cxxToolChainInfo.macroInspectionRunner = [](const QStringList &) {
t.projectUpdateInfo.cxxToolchainInfo.macroInspectionRunner = [](const QStringList &) {
return TestToolchain::MacroInspectionReport{Macros(), Utils::LanguageVersion::CXX17};
};
t.rawProjectPart.files = QStringList{ "foo.cpp" };

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

@@ -364,7 +364,7 @@ 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);

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
@@ -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);
@@ -599,7 +599,7 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
toolChain->setDisplayName(target.name);
toolChain->setPlatformCodeGenFlags(target.backendFlags);
toolChain->setPlatformLinkerFlags(target.backendFlags);
toolChain->resetToolChain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ?
toolChain->resetToolchain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ?
platform.cxxCompilerPath : platform.cCompilerPath);
existingClangToolChains.append(toolChain);
}

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

@@ -85,10 +85,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/mesonbuildsystem.cpp
View File

@@ -245,7 +245,7 @@ void MesonBuildSystem::parsingCompleted(bool success)
{project(),
QtSupport::CppKitInfo(kit()),
buildConfiguration()->environment(),
m_parser.buildProjectParts(kitInfo.cxxToolChain, kitInfo.cToolChain)});
m_parser.buildProjectParts(kitInfo.cxxToolchain, kitInfo.cToolchain)});
}
setApplicationTargets(m_parser.appsTargets());
UNLOCK(true);

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");

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

@@ -458,7 +458,7 @@ static const GccToolchain *mingwToolChainFromId(const QByteArray &id)
QString GccToolchain::originalTargetTriple() const
{
if (m_subType == Clang) {
if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId))
if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolchainId))
return parentTC->originalTargetTriple();
}
@@ -866,7 +866,7 @@ QStringList GccToolchain::suggestedMkspecList() const
}
if (m_subType == Clang) {
if (const Toolchain * const parentTc = ToolchainManager::findToolchain(m_parentToolChainId))
if (const Toolchain * const parentTc = ToolchainManager::findToolchain(m_parentToolchainId))
return parentTc->suggestedMkspecList();
const Abi abi = targetAbi();
if (abi.os() == Abi::DarwinOS)
@@ -950,7 +950,7 @@ QList<OutputLineParser *> GccToolchain::createOutputParsers() const
return GccParser::gccParserSuite();
}
void GccToolchain::resetToolChain(const FilePath &path)
void GccToolchain::resetToolchain(const FilePath &path)
{
bool resetDisplayName = (displayName() == defaultDisplayName());
@@ -1021,7 +1021,7 @@ void GccToolchain::toMap(Store &data) const
data.insert(supportedAbisKeyC, Utils::transform<QStringList>(m_supportedAbis, &Abi::toString));
if (m_subType == Clang) {
data.insert(parentToolChainIdKeyC, m_parentToolChainId);
data.insert(parentToolChainIdKeyC, m_parentToolchainId);
data.insert(priorityKeyC, m_priority);
}
}
@@ -1042,10 +1042,10 @@ void GccToolchain::fromMap(const Store &data)
const QString targetAbiString = data.value(targetAbiKeyC).toString();
if (targetAbiString.isEmpty())
resetToolChain(compilerCommand());
resetToolchain(compilerCommand());
if (m_subType == Clang) {
m_parentToolChainId = data.value(parentToolChainIdKeyC).toByteArray();
m_parentToolchainId = data.value(parentToolChainIdKeyC).toByteArray();
m_priority = data.value(priorityKeyC, PriorityNormal).toInt();
syncAutodetectedWithParentToolchains();
}
@@ -1814,13 +1814,13 @@ void GccToolchainConfigWidget::applyImpl()
if (m_subType == GccToolchain::Clang && m_parentToolchainCombo) {
tc->m_parentToolChainId.clear();
tc->m_parentToolchainId.clear();
const QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
if (!parentId.isEmpty()) {
for (const Toolchain *mingwTC : mingwToolChains()) {
if (parentId == mingwTC->id()) {
tc->m_parentToolChainId = mingwTC->id();
tc->m_parentToolchainId = mingwTC->id();
tc->setTargetAbi(mingwTC->targetAbi());
tc->setSupportedAbis(mingwTC->supportedAbis());
break;
@@ -1868,7 +1868,7 @@ bool GccToolchainConfigWidget::isDirtyImpl() const
if (!m_parentToolchainCombo)
return false;
const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolChainId);
const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolchainId);
const QByteArray parentId = parentTC ? parentTC->id() : QByteArray();
return parentId != m_parentToolchainCombo->currentData();
}
@@ -1967,9 +1967,9 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
return;
}
if (!mingwToolChainFromId(m_parentToolChainId)) {
if (!mingwToolChainFromId(m_parentToolchainId)) {
const Toolchains mingwTCs = mingwToolChains();
m_parentToolChainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
}
// Subscribe only autodetected toolchains.
@@ -1977,8 +1977,8 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
m_mingwToolchainAddedConnection
= connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
&& !mingwToolChainFromId(m_parentToolChainId)) {
m_parentToolChainId = tc->id();
&& !mingwToolChainFromId(m_parentToolchainId)) {
m_parentToolchainId = tc->id();
}
});
m_thisToolchainRemovedConnection
@@ -1986,9 +1986,9 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
if (tc == this) {
QObject::disconnect(m_thisToolchainRemovedConnection);
QObject::disconnect(m_mingwToolchainAddedConnection);
} else if (m_parentToolChainId == tc->id()) {
} else if (m_parentToolchainId == tc->id()) {
const Toolchains mingwTCs = mingwToolChains();
m_parentToolChainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
}
});
}
@@ -2018,7 +2018,7 @@ bool GccToolchain::matchesCompilerCommand(const FilePath &command) const
QString GccToolchain::sysRoot() const
{
if (m_subType == Clang) {
if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolChainId)) {
if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolchainId)) {
const FilePath mingwCompiler = parentTC->compilerCommand();
return mingwCompiler.parentDir().parentDir().toString();
}
@@ -2033,7 +2033,7 @@ void GccToolchainConfigWidget::updateParentToolChainComboBox()
auto *tc = static_cast<GccToolchain *>(toolChain());
QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
parentId = tc->m_parentToolChainId;
parentId = tc->m_parentToolchainId;
const GccToolchain *parentTC = mingwToolChainFromId(parentId);

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

@@ -59,7 +59,7 @@ public:
bool operator ==(const Toolchain &) const override;
void resetToolChain(const Utils::FilePath &);
void resetToolchain(const Utils::FilePath &);
void setPlatformCodeGenFlags(const QStringList &);
QStringList extraCodeModelFlags() const override;
QStringList platformCodeGenFlags() const;
@@ -155,7 +155,7 @@ private:
// "resolved" on macOS from /usr/bin/clang(++) etc to <DeveloperDir>/usr/bin/clang(++)
// which is used for comparison with matchesCompilerCommand
mutable std::optional<Utils::FilePath> m_resolvedCompilerCommand;
QByteArray m_parentToolChainId;
QByteArray m_parentToolchainId;
int m_priority = PriorityNormal;
QMetaObject::Connection m_mingwToolchainAddedConnection;
QMetaObject::Connection m_thisToolchainRemovedConnection;

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

@@ -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)
@@ -386,7 +386,7 @@ Tasks ToolchainKitAspectFactory::validate(const Kit *k) const
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) {
@@ -407,12 +407,12 @@ 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
}
}
}
@@ -459,9 +459,9 @@ 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);
@@ -475,19 +475,19 @@ KitAspect *ToolchainKitAspectFactory::createKitAspect(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
{
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
{
Toolchain *tc = ToolchainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolchainKitAspect::cxxToolchain(k);
if (tc)
tc->addToEnvironment(env);
}
@@ -499,25 +499,25 @@ void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expa
// 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();
});
}
@@ -525,7 +525,7 @@ void ToolchainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expa
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 {};
@@ -546,7 +546,7 @@ Id ToolchainKitAspect::id()
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)
@@ -555,19 +555,19 @@ QByteArray ToolchainKitAspect::toolChainId(const Kit *k, Id language)
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));
}
@@ -583,7 +583,7 @@ 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);
@@ -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);
@@ -642,7 +642,7 @@ 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);
@@ -685,7 +685,7 @@ 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.");
}
@@ -704,7 +704,7 @@ void ToolchainKitAspectFactory::onKitsLoaded()
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);
}
}

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

@@ -24,23 +24,23 @@ public:
static void setSysRoot(Kit *k, const Utils::FilePath &v);
};
// ToolChainKitAspect
// ToolchainKitAspect
class PROJECTEXPLORER_EXPORT ToolchainKitAspect
{
public:
static Utils::Id id();
static QByteArray toolChainId(const Kit *k, Utils::Id language);
static Toolchain *toolChain(const Kit *k, Utils::Id language);
static Toolchain *cToolChain(const Kit *k);
static Toolchain *cxxToolChain(const Kit *k);
static QByteArray toolchainId(const Kit *k, Utils::Id language);
static Toolchain *toolchain(const Kit *k, Utils::Id language);
static Toolchain *cToolchain(const Kit *k);
static Toolchain *cxxToolchain(const Kit *k);
static QList<Toolchain *> toolChains(const Kit *k);
static void setToolChain(Kit *k, Toolchain *tc);
static void setAllToolChainsToMatch(Kit *k, Toolchain *tc);
static void clearToolChain(Kit *k, Utils::Id language);
static void setToolchain(Kit *k, Toolchain *tc);
static void setAllToolchainsToMatch(Kit *k, Toolchain *tc);
static void clearToolchain(Kit *k, Utils::Id language);
static Abi targetAbi(const Kit *k);
static QString msgNoToolChainInTarget();
static QString msgNoToolchainInTarget();
};
// DeviceTypeKitAspect

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

@@ -347,7 +347,7 @@ 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());

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()) {

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

@@ -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);
}

8
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
@@ -185,8 +185,8 @@ ProjectUpdateInfo::ProjectUpdateInfo(Project *project,
const RppGenerator &rppGenerator)
: rawProjectParts(rawProjectParts)
, rppGenerator(rppGenerator)
, cToolChainInfo(ToolChainInfo(kitInfo.cToolChain, kitInfo.sysRootPath, env))
, cxxToolChainInfo(ToolChainInfo(kitInfo.cxxToolChain, kitInfo.sysRootPath, env))
, cToolchainInfo(ToolChainInfo(kitInfo.cToolchain, kitInfo.sysRootPath, env))
, cxxToolchainInfo(ToolChainInfo(kitInfo.cxxToolchain, kitInfo.sysRootPath, env))
{
if (project) {
projectName = project->displayName();

8
src/plugins/projectexplorer/rawprojectpart.h
View File

@@ -119,8 +119,8 @@ public:
bool isValid() const;
Kit *kit = nullptr;
Toolchain *cToolChain = nullptr;
Toolchain *cxxToolChain = nullptr;
Toolchain *cToolchain = nullptr;
Toolchain *cxxToolchain = nullptr;
Utils::QtMajorVersion projectPartQtVersion = Utils::QtMajorVersion::None;
@@ -171,8 +171,8 @@ public:
RawProjectParts rawProjectParts;
RppGenerator rppGenerator;
ToolChainInfo cToolChainInfo;
ToolChainInfo cxxToolChainInfo;
ToolChainInfo cToolchainInfo;
ToolChainInfo cxxToolchainInfo;
};
} // namespace ProjectExplorer

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/qbsproject.cpp
View File

@@ -1005,10 +1005,10 @@ void QbsBuildSystem::updateCppCodeModel()
const QtSupport::CppKitInfo kitInfo(kit());
QTC_ASSERT(kitInfo.isValid(), return);
const auto cToolchain = std::shared_ptr<Toolchain>(kitInfo.cToolChain
? kitInfo.cToolChain->clone() : nullptr);
const auto cxxToolchain = std::shared_ptr<Toolchain>(kitInfo.cxxToolChain
? kitInfo.cxxToolChain->clone() : nullptr);
const auto cToolchain = std::shared_ptr<Toolchain>(kitInfo.cToolchain
? kitInfo.cToolchain->clone() : nullptr);
const auto cxxToolchain = std::shared_ptr<Toolchain>(kitInfo.cxxToolchain
? kitInfo.cxxToolchain->clone() : nullptr);
m_cppCodeModelUpdater->update({project(), kitInfo, activeParseEnvironment(), {},
[projectData, kitInfo, cToolchain, cxxToolchain] {

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

@@ -145,8 +145,8 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
&& 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;

16
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();
});
@@ -362,8 +362,8 @@ void QmakeBuildSystem::updateCppCodeModel()
return pro->variableValue(Variable::IosDeploymentTarget).join(QString());
});
rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxArgs, includeFileBaseDir});
rpp.setFlagsForC({kitInfo.cToolChain, cArgs, includeFileBaseDir});
rpp.setFlagsForCxx({kitInfo.cxxToolchain, cxxArgs, includeFileBaseDir});
rpp.setFlagsForC({kitInfo.cToolchain, cArgs, includeFileBaseDir});
rpp.setMacros(ProjectExplorer::Macro::toMacros(pro->cxxDefines()));
rpp.setPreCompiledHeaders(pro->variableValue(Variable::PrecompiledHeader));
rpp.setSelectedForBuilding(pro->includedInExactParse());
@@ -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);
}
}
@@ -240,7 +240,7 @@ Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
.arg(target.shortDescription()));
toolChain->sdpPath.setValue(m_envFile.parentDir());
toolChain->cpuDir.setValue(target.cpuDir());
toolChain->resetToolChain(m_qccCompiler);
toolChain->resetToolchain(m_qccCompiler);
ToolchainManager::registerToolchain(toolChain);
toolChains.append(toolChain);
@@ -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);

2
src/plugins/qnx/qnxtoolchain.cpp
View File

@@ -208,7 +208,7 @@ void QnxToolChainConfigWidget::applyImpl()
tc->setDisplayName(displayName); // reset display name
tc->sdpPath.setValue(m_sdpPath->filePath());
tc->setTargetAbi(m_abiWidget->currentAbi());
tc->resetToolChain(m_compilerCommand->filePath());
tc->resetToolchain(m_compilerCommand->filePath());
}
void QnxToolChainConfigWidget::discardImpl()

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);
}

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

@@ -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))