Differential D11136 Diff 29007 plugins/custom-definesandincludes/compilerprovider/compilerprovider.cpp

Changeset View

Standalone View

View Options

plugins/custom-definesandincludes/compilerprovider/compilerprovider.cpp

Show All 25 Lines
26#include "debug.h" 26​#include "debug.h"
27#include "qtcompat_p.h" 27​#include "qtcompat_p.h"
28#include "compilerfactories.h" 28​#include "compilerfactories.h"
29#include "settingsmanager.h" 29​#include "settingsmanager.h"
30 30​
31#include <interfaces/iruntime.h> 31​#include <interfaces/iruntime.h>
32#include <interfaces/iruntimecontroller.h> 32​#include <interfaces/iruntimecontroller.h>
33#include <interfaces/iproject.h> 33​#include <interfaces/iproject.h>
34​#include <interfaces/iprojectcontroller.h>
35​#include <interfaces/ibuildsystemmanager.h>
34#include <project/projectmodel.h> 36​#include <project/projectmodel.h>
35 37​
36#include <KLocalizedString> 38​#include <KLocalizedString>
37#include <QStandardPaths> 39​#include <QStandardPaths>
38#include <QDir> 40​#include <QDir>
39 41​
mwolffUnsubmitted
Done

move up, add interfaces/

mwolff: move up, add interfaces/
40using namespace KDevelop; 42​using namespace KDevelop;
41 43​
42namespace 44​namespace
43{ 45​{
44class NoCompiler : public ICompiler 46​class NoCompiler : public ICompiler
45{ 47​{
46public: 48​public:
47 NoCompiler(): 49​ NoCompiler():
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Line(s)94 if (targetDirectory.isParentOf(itemPath)) {
96 } 98​ }
97 } 99​ }
98 } 100​ }
99 101​
100 return config; 102​ return config;
101} 103​}
102} 104​}
103 105​
106​ProjectTargetItem* findCompiledTarget(ProjectBaseItem* item)
107​{
108​ for(auto item: item->targetList()) {
109​ if (item->type() == ProjectBaseItem::ExecutableTarget || item->type() == ProjectBaseItem::LibraryTarget) {
110​ return item;
111​ }
112​ }
113​
114​ for(auto folder: item->folderList()) {
115​ auto target = findCompiledTarget(folder);
116​ if (target)
117​ return target;
118​ }
119​ return nullptr;
120​}
121​
104CompilerProvider::CompilerProvider( SettingsManager* settings, QObject* parent ) 122​CompilerProvider::CompilerProvider( SettingsManager* settings, QObject* parent )
105 : QObject( parent ) 123​ : QObject( parent )
106 , m_settings(settings) 124​ , m_settings(settings)
107{ 125​{
108 m_factories.append(CompilerFactoryPointer(new GccFactory())); 126​ m_factories.append(CompilerFactoryPointer(new GccFactory()));
109 m_factories.append(CompilerFactoryPointer(new ClangFactory())); 127​ m_factories.append(CompilerFactoryPointer(new ClangFactory()));
110#ifdef _WIN32 128​#ifdef _WIN32
111 m_factories.append(CompilerFactoryPointer(new MsvcFactory())); 129​ m_factories.append(CompilerFactoryPointer(new MsvcFactory()));
Show All 9 Lines138#ifdef _WIN32
121 if (!QStandardPaths::findExecutable("cl.exe").isEmpty()) { 139​ if (!QStandardPaths::findExecutable("cl.exe").isEmpty()) {
122 m_factories[2]->registerDefaultCompilers(this); 140​ m_factories[2]->registerDefaultCompilers(this);
123 } 141​ }
124#endif 142​#endif
125 143​
126 registerCompiler(createDummyCompiler()); 144​ registerCompiler(createDummyCompiler());
127 retrieveUserDefinedCompilers(); 145​ retrieveUserDefinedCompilers();
128 146​
129 connect(ICore::self()->runtimeController(), &IRuntimeController::currentRuntimeChanged, this, [this]() { m_defaultProvider.clear(); }); 147​ connect(ICore::self()->runtimeController(), &IRuntimeController::currentRuntimeChanged, this, [this]() {
148​ m_defaultProvider.clear();
149​
150​ for (auto p : ICore::self()->projectController()->projects()) {
151​ const auto target = findCompiledTarget(p->projectItem());
152​ if (!target)
153​ continue;
154​
155​ auto path = p->buildSystemManager()->compiler(target);
mwolffUnsubmitted
Not Done

I find it odd that this is the only place where this new API is being used, no? shouldn't it also be used elswhere? like, when we don't really use runtimes at all?

mwolff: I find it odd that this is the only place where this new API is being used, no? shouldn't it…
156​ qCDebug(DEFINESANDINCLUDES) << "found compiler" << path;
157​ if (!path.isEmpty())
mwolffUnsubmitted
Done

this isAbsolutePath check - shouldn't it be an assertion? the BSM should sanitize and produce absolute paths, I'd say (like, based on the build/source dir)

mwolff: this isAbsolutePath check - shouldn't it be an assertion? the BSM should sanitize and produce…
mwolffUnsubmitted
Not Done

the ! is wrong, no? otherwise you only run the code below when the path is empty, which sounds odd

mwolff: the ! is wrong, no? otherwise you only run the code below when the path is empty, which sounds…
158​ continue;
159​
160​ Q_ASSERT(QDir::isAbsolutePath(path.toLocalFile()));
161​ const auto pathString = path.toLocalFile();
162​ auto it = std::find_if(m_compilers.begin(), m_compilers.end(),
mwolffUnsubmitted
Not Done

for (const auto& compiler : m_compilers)

or better yet:

if (std::any_of(m_compilers.begin(), m_compilers.end(),
    [pathString](const auto& compiler) { compiler->path() == pathString; })
{
    continue;
}
mwolff: `for (const auto& compiler : m_compilers)` or better yet: ``` if (std::any_of(m_compilers.
163​ [pathString](const CompilerPointer& compiler) { return compiler->path() == pathString; });
164​ if (it != m_compilers.end())
165​ {
166​ m_defaultProvider = *it;
167​ continue;
168​ } else {
mwolffUnsubmitted
Not Done

no need for the else + indentation, you continue above

mwolff: no need for the else + indentation, you continue above
169​ //we need to search, sdk compiler names are weird: arm-linux-androideabi-g++
170​ for (auto factory : m_factories) {
171​ if (factory->isSupported(path)) {
mwolffUnsubmitted
Done

this looks weird to me - this shouldn't be hardcoded like this, no? it should go through all factories and find a match. I.e. on windows we may need to use the msvc factory?

mwolff: this looks weird to me - this shouldn't be hardcoded like this, no? it should go through all…
172​ auto compiler = factory->createCompiler(path.lastPathSegment(), pathString);
173​ const auto registered = registerCompiler(compiler);
174​ Q_ASSERT(registered); //it's ensured by the other branch of the if
175​ m_defaultProvider = compiler;
176​ }
177​ }
178​ }
179​
180​ qCDebug(DEFINESANDINCLUDES) << "using compiler" << m_defaultProvider;
181​ }
182​ }, Qt::QueuedConnection);
130} 183​}
131 184​
132CompilerProvider::~CompilerProvider() = default; 185​CompilerProvider::~CompilerProvider() = default;
133 186​
134QHash<QString, QString> CompilerProvider::defines( const QString& path ) const 187​QHash<QString, QString> CompilerProvider::defines( const QString& path ) const
135{ 188​{
136 auto config = configForItem(nullptr); 189​ auto config = configForItem(nullptr);
137 auto languageType = Utils::languageType(path, config.parserArguments.parseAmbiguousAsCPP); 190​ auto languageType = Utils::languageType(path, config.parserArguments.parseAmbiguousAsCPP);
138 // If called on files that we can't compile, return an empty set of defines. 191​ // If called on files that we can't compile, return an empty set of defines.
139 if (languageType == Utils::Other) { 192​ if (languageType == Utils::Other) {
140 return {}; 193​ return {};
141 } 194​ }
142 195​
143 return config.compiler->defines(languageType, config.parserArguments[languageType]); 196​ return config.compiler->defines(languageType, config.parserArguments[languageType]);
144} 197​}
145 198​
146QHash<QString, QString> CompilerProvider::defines( ProjectBaseItem* item ) const 199​QHash<QString, QString> CompilerProvider::defines( ProjectBaseItem* item ) const
147{ 200​{
148 auto config = configForItem(item); 201​ auto config = configForItem(item);
149 auto languageType = Utils::Cpp; 202​ auto languageType = Utils::Cpp;
mwolffUnsubmitted
Done

join next line

mwolff: join next line
150 if (item) { 203​ if (item) {
151 languageType = Utils::languageType(item->path().path(), config.parserArguments.parseAmbiguousAsCPP); 204​ languageType = Utils::languageType(item->path().path(), config.parserArguments.parseAmbiguousAsCPP);
152 } 205​ }
153 // If called on files that we can't compile, return an empty set of defines. 206​ // If called on files that we can't compile, return an empty set of defines.
154 if (languageType == Utils::Other) { 207​ if (languageType == Utils::Other) {
155 return {}; 208​ return {};
156 } 209​ }
157 210​
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines