1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Contact: https://www.qt.io/licensing/
5 **
6 ** This file is part of Qt Creator.
7 **
8 ** Commercial License Usage
9 ** Licensees holding valid commercial Qt licenses may use this file in
10 ** accordance with the commercial license agreement provided with the
11 ** Software or, alternatively, in accordance with the terms contained in
12 ** a written agreement between you and The Qt Company. For licensing terms
13 ** and conditions see https://www.qt.io/terms-conditions. For further
14 ** information use the contact form at https://www.qt.io/contact-us.
15 **
16 ** GNU General Public License Usage
17 ** Alternatively, this file may be used under the terms of the GNU
18 ** General Public License version 3 as published by the Free Software
19 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
20 ** included in the packaging of this file. Please review the following
21 ** information to ensure the GNU General Public License requirements will
22 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
23 **
24 ****************************************************************************/
25
26 #include "cppcodemodelsettings.h"
27
28 #include "clangdiagnosticconfigsmodel.h"
29 #include "cpptoolsconstants.h"
30 #include "cpptoolsreuse.h"
31
32 #include <coreplugin/icore.h>
33 #include <projectexplorer/project.h>
34
35 #include <utils/algorithm.h>
36 #include <utils/qtcassert.h>
37
38 #include <QSettings>
39
40 using namespace CppTools;
41 using namespace Utils;
42
initialClangDiagnosticConfigId()43 static Utils::Id initialClangDiagnosticConfigId()
44 { return Constants::CPP_CLANG_DIAG_CONFIG_BUILDSYSTEM; }
45
initialPchUsage()46 static CppCodeModelSettings::PCHUsage initialPchUsage()
47 { return CppCodeModelSettings::PchUse_BuildSystem; }
48
clangDiagnosticConfigKey()49 static QString clangDiagnosticConfigKey()
50 { return QStringLiteral("ClangDiagnosticConfig"); }
51
enableLowerClazyLevelsKey()52 static QString enableLowerClazyLevelsKey()
53 { return QLatin1String("enableLowerClazyLevels"); }
54
pchUsageKey()55 static QString pchUsageKey()
56 { return QLatin1String(Constants::CPPTOOLS_MODEL_MANAGER_PCH_USAGE); }
57
interpretAmbiguousHeadersAsCHeadersKey()58 static QString interpretAmbiguousHeadersAsCHeadersKey()
59 { return QLatin1String(Constants::CPPTOOLS_INTERPRET_AMBIGIUOUS_HEADERS_AS_C_HEADERS); }
60
skipIndexingBigFilesKey()61 static QString skipIndexingBigFilesKey()
62 { return QLatin1String(Constants::CPPTOOLS_SKIP_INDEXING_BIG_FILES); }
63
indexerFileSizeLimitKey()64 static QString indexerFileSizeLimitKey()
65 { return QLatin1String(Constants::CPPTOOLS_INDEXER_FILE_SIZE_LIMIT); }
66
clangdSettingsKey()67 static QString clangdSettingsKey() { return QLatin1String("ClangdSettings"); }
useClangdKey()68 static QString useClangdKey() { return QLatin1String("UseClangd"); }
clangdPathKey()69 static QString clangdPathKey() { return QLatin1String("ClangdPath"); }
clangdIndexingKey()70 static QString clangdIndexingKey() { return QLatin1String("ClangdIndexing"); }
clangdThreadLimitKey()71 static QString clangdThreadLimitKey() { return QLatin1String("ClangdThreadLimit"); }
clangdUseGlobalSettingsKey()72 static QString clangdUseGlobalSettingsKey() { return QLatin1String("useGlobalSettings"); }
73
74 static FilePath g_defaultClangdFilePath;
fallbackClangdFilePath()75 static FilePath fallbackClangdFilePath()
76 {
77 if (g_defaultClangdFilePath.exists())
78 return g_defaultClangdFilePath;
79 return FilePath::fromString("clangd");
80 }
81
clangDiagnosticConfigIdFromSettings(QSettings * s)82 static Utils::Id clangDiagnosticConfigIdFromSettings(QSettings *s)
83 {
84 QTC_ASSERT(s->group() == QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP), return Utils::Id());
85
86 return Utils::Id::fromSetting(
87 s->value(clangDiagnosticConfigKey(), initialClangDiagnosticConfigId().toSetting()));
88 }
89
90 // Removed since Qt Creator 4.11
removedBuiltinConfigs()91 static ClangDiagnosticConfigs removedBuiltinConfigs()
92 {
93 ClangDiagnosticConfigs configs;
94
95 // Pedantic
96 ClangDiagnosticConfig config;
97 config.setId("Builtin.Pedantic");
98 config.setDisplayName(QCoreApplication::translate("ClangDiagnosticConfigsModel",
99 "Pedantic checks"));
100 config.setIsReadOnly(true);
101 config.setClangOptions(QStringList{QStringLiteral("-Wpedantic")});
102 config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::UseCustomChecks);
103 config.setClazyMode(ClangDiagnosticConfig::ClazyMode::UseCustomChecks);
104 configs << config;
105
106 // Everything with exceptions
107 config = ClangDiagnosticConfig();
108 config.setId("Builtin.EverythingWithExceptions");
109 config.setDisplayName(QCoreApplication::translate(
110 "ClangDiagnosticConfigsModel",
111 "Checks for almost everything"));
112 config.setIsReadOnly(true);
113 config.setClangOptions(QStringList{
114 QStringLiteral("-Weverything"),
115 QStringLiteral("-Wno-c++98-compat"),
116 QStringLiteral("-Wno-c++98-compat-pedantic"),
117 QStringLiteral("-Wno-unused-macros"),
118 QStringLiteral("-Wno-newline-eof"),
119 QStringLiteral("-Wno-exit-time-destructors"),
120 QStringLiteral("-Wno-global-constructors"),
121 QStringLiteral("-Wno-gnu-zero-variadic-macro-arguments"),
122 QStringLiteral("-Wno-documentation"),
123 QStringLiteral("-Wno-shadow"),
124 QStringLiteral("-Wno-switch-enum"),
125 QStringLiteral("-Wno-missing-prototypes"), // Not optimal for C projects.
126 QStringLiteral("-Wno-used-but-marked-unused"), // e.g. QTest::qWait
127 });
128 config.setClangTidyMode(ClangDiagnosticConfig::TidyMode::UseCustomChecks);
129 config.setClazyMode(ClangDiagnosticConfig::ClazyMode::UseCustomChecks);
130 configs << config;
131
132 return configs;
133 }
134
convertToCustomConfig(const Utils::Id & id)135 static ClangDiagnosticConfig convertToCustomConfig(const Utils::Id &id)
136 {
137 const ClangDiagnosticConfig config
138 = Utils::findOrDefault(removedBuiltinConfigs(), [id](const ClangDiagnosticConfig &config) {
139 return config.id() == id;
140 });
141 return ClangDiagnosticConfigsModel::createCustomConfig(config, config.displayName());
142 }
143
fromSettings(QSettings * s)144 void CppCodeModelSettings::fromSettings(QSettings *s)
145 {
146 s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
147
148 setClangCustomDiagnosticConfigs(diagnosticConfigsFromSettings(s));
149 setClangDiagnosticConfigId(clangDiagnosticConfigIdFromSettings(s));
150
151 // Qt Creator 4.11 removes some built-in configs.
152 bool write = false;
153 const Utils::Id id = m_clangDiagnosticConfigId;
154 if (id == "Builtin.Pedantic" || id == "Builtin.EverythingWithExceptions") {
155 // If one of them was used, continue to use it, but convert it to a custom config.
156 const ClangDiagnosticConfig customConfig = convertToCustomConfig(id);
157 m_clangCustomDiagnosticConfigs.append(customConfig);
158 m_clangDiagnosticConfigId = customConfig.id();
159 write = true;
160 }
161
162 // Before Qt Creator 4.8, inconsistent settings might have been written.
163 const ClangDiagnosticConfigsModel model = diagnosticConfigsModel(m_clangCustomDiagnosticConfigs);
164 if (!model.hasConfigWithId(m_clangDiagnosticConfigId))
165 setClangDiagnosticConfigId(initialClangDiagnosticConfigId());
166
167 setEnableLowerClazyLevels(s->value(enableLowerClazyLevelsKey(), true).toBool());
168
169 const QVariant pchUsageVariant = s->value(pchUsageKey(), initialPchUsage());
170 setPCHUsage(static_cast<PCHUsage>(pchUsageVariant.toInt()));
171
172 const QVariant interpretAmbiguousHeadersAsCHeaders
173 = s->value(interpretAmbiguousHeadersAsCHeadersKey(), false);
174 setInterpretAmbigiousHeadersAsCHeaders(interpretAmbiguousHeadersAsCHeaders.toBool());
175
176 const QVariant skipIndexingBigFiles = s->value(skipIndexingBigFilesKey(), true);
177 setSkipIndexingBigFiles(skipIndexingBigFiles.toBool());
178
179 const QVariant indexerFileSizeLimit = s->value(indexerFileSizeLimitKey(), 5);
180 setIndexerFileSizeLimitInMb(indexerFileSizeLimit.toInt());
181
182 s->endGroup();
183
184 if (write)
185 toSettings(s);
186
187 emit changed();
188 }
189
toSettings(QSettings * s)190 void CppCodeModelSettings::toSettings(QSettings *s)
191 {
192 s->beginGroup(QLatin1String(Constants::CPPTOOLS_SETTINGSGROUP));
193 const ClangDiagnosticConfigs previousConfigs = diagnosticConfigsFromSettings(s);
194 const Utils::Id previousConfigId = clangDiagnosticConfigIdFromSettings(s);
195
196 diagnosticConfigsToSettings(s, m_clangCustomDiagnosticConfigs);
197
198 s->setValue(clangDiagnosticConfigKey(), clangDiagnosticConfigId().toSetting());
199 s->setValue(enableLowerClazyLevelsKey(), enableLowerClazyLevels());
200 s->setValue(pchUsageKey(), pchUsage());
201
202 s->setValue(interpretAmbiguousHeadersAsCHeadersKey(), interpretAmbigiousHeadersAsCHeaders());
203 s->setValue(skipIndexingBigFilesKey(), skipIndexingBigFiles());
204 s->setValue(indexerFileSizeLimitKey(), indexerFileSizeLimitInMb());
205
206 s->endGroup();
207
208 QVector<Utils::Id> invalidated
209 = ClangDiagnosticConfigsModel::changedOrRemovedConfigs(previousConfigs,
210 m_clangCustomDiagnosticConfigs);
211
212 if (previousConfigId != clangDiagnosticConfigId() && !invalidated.contains(previousConfigId))
213 invalidated.append(previousConfigId);
214
215 if (!invalidated.isEmpty())
216 emit clangDiagnosticConfigsInvalidated(invalidated);
217 emit changed();
218 }
219
clangDiagnosticConfigId() const220 Utils::Id CppCodeModelSettings::clangDiagnosticConfigId() const
221 {
222 if (!diagnosticConfigsModel().hasConfigWithId(m_clangDiagnosticConfigId))
223 return defaultClangDiagnosticConfigId();
224 return m_clangDiagnosticConfigId;
225 }
226
setClangDiagnosticConfigId(const Utils::Id & configId)227 void CppCodeModelSettings::setClangDiagnosticConfigId(const Utils::Id &configId)
228 {
229 m_clangDiagnosticConfigId = configId;
230 }
231
defaultClangDiagnosticConfigId()232 Utils::Id CppCodeModelSettings::defaultClangDiagnosticConfigId()
233 {
234 return initialClangDiagnosticConfigId();
235 }
236
clangDiagnosticConfig() const237 const ClangDiagnosticConfig CppCodeModelSettings::clangDiagnosticConfig() const
238 {
239 const ClangDiagnosticConfigsModel configsModel = diagnosticConfigsModel(
240 m_clangCustomDiagnosticConfigs);
241
242 return configsModel.configWithId(clangDiagnosticConfigId());
243 }
244
clangCustomDiagnosticConfigs() const245 ClangDiagnosticConfigs CppCodeModelSettings::clangCustomDiagnosticConfigs() const
246 {
247 return m_clangCustomDiagnosticConfigs;
248 }
249
setClangCustomDiagnosticConfigs(const ClangDiagnosticConfigs & configs)250 void CppCodeModelSettings::setClangCustomDiagnosticConfigs(const ClangDiagnosticConfigs &configs)
251 {
252 m_clangCustomDiagnosticConfigs = configs;
253 }
254
pchUsage() const255 CppCodeModelSettings::PCHUsage CppCodeModelSettings::pchUsage() const
256 {
257 return m_pchUsage;
258 }
259
setPCHUsage(CppCodeModelSettings::PCHUsage pchUsage)260 void CppCodeModelSettings::setPCHUsage(CppCodeModelSettings::PCHUsage pchUsage)
261 {
262 m_pchUsage = pchUsage;
263 }
264
interpretAmbigiousHeadersAsCHeaders() const265 bool CppCodeModelSettings::interpretAmbigiousHeadersAsCHeaders() const
266 {
267 return m_interpretAmbigiousHeadersAsCHeaders;
268 }
269
setInterpretAmbigiousHeadersAsCHeaders(bool yesno)270 void CppCodeModelSettings::setInterpretAmbigiousHeadersAsCHeaders(bool yesno)
271 {
272 m_interpretAmbigiousHeadersAsCHeaders = yesno;
273 }
274
skipIndexingBigFiles() const275 bool CppCodeModelSettings::skipIndexingBigFiles() const
276 {
277 return m_skipIndexingBigFiles;
278 }
279
setSkipIndexingBigFiles(bool yesno)280 void CppCodeModelSettings::setSkipIndexingBigFiles(bool yesno)
281 {
282 m_skipIndexingBigFiles = yesno;
283 }
284
indexerFileSizeLimitInMb() const285 int CppCodeModelSettings::indexerFileSizeLimitInMb() const
286 {
287 return m_indexerFileSizeLimitInMB;
288 }
289
setIndexerFileSizeLimitInMb(int sizeInMB)290 void CppCodeModelSettings::setIndexerFileSizeLimitInMb(int sizeInMB)
291 {
292 m_indexerFileSizeLimitInMB = sizeInMB;
293 }
294
enableLowerClazyLevels() const295 bool CppCodeModelSettings::enableLowerClazyLevels() const
296 {
297 return m_enableLowerClazyLevels;
298 }
299
setEnableLowerClazyLevels(bool yesno)300 void CppCodeModelSettings::setEnableLowerClazyLevels(bool yesno)
301 {
302 m_enableLowerClazyLevels = yesno;
303 }
304
305
instance()306 ClangdSettings &ClangdSettings::instance()
307 {
308 static ClangdSettings settings;
309 return settings;
310 }
311
setDefaultClangdPath(const Utils::FilePath & filePath)312 void ClangdSettings::setDefaultClangdPath(const Utils::FilePath &filePath)
313 {
314 g_defaultClangdFilePath = filePath;
315 }
316
clangdFilePath() const317 FilePath ClangdSettings::clangdFilePath() const
318 {
319 if (!m_data.executableFilePath.isEmpty())
320 return m_data.executableFilePath;
321 return fallbackClangdFilePath();
322 }
323
setData(const Data & data)324 void ClangdSettings::setData(const Data &data)
325 {
326 if (this == &instance() && data != m_data) {
327 m_data = data;
328 saveSettings();
329 emit changed();
330 }
331 }
332
loadSettings()333 void ClangdSettings::loadSettings()
334 {
335 m_data.fromMap(Core::ICore::settings()->value(clangdSettingsKey()).toMap());
336 }
337
saveSettings()338 void ClangdSettings::saveSettings()
339 {
340 Core::ICore::settings()->setValue(clangdSettingsKey(), m_data.toMap());
341 }
342
343 #ifdef WITH_TESTS
setUseClangd(bool use)344 void ClangdSettings::setUseClangd(bool use) { instance().m_data.useClangd = use; }
setClangdFilePath(const Utils::FilePath & filePath)345 void ClangdSettings::setClangdFilePath(const Utils::FilePath &filePath)
346 {
347 instance().m_data.executableFilePath = filePath;
348 }
349 #endif
350
ClangdProjectSettings(ProjectExplorer::Project * project)351 ClangdProjectSettings::ClangdProjectSettings(ProjectExplorer::Project *project) : m_project(project)
352 {
353 loadSettings();
354 }
355
settings() const356 ClangdSettings::Data ClangdProjectSettings::settings() const
357 {
358 if (m_useGlobalSettings)
359 return ClangdSettings::instance().data();
360 return m_customSettings;
361 }
362
setSettings(const ClangdSettings::Data & data)363 void ClangdProjectSettings::setSettings(const ClangdSettings::Data &data)
364 {
365 m_customSettings = data;
366 saveSettings();
367 emit ClangdSettings::instance().changed();
368 }
369
setUseGlobalSettings(bool useGlobal)370 void ClangdProjectSettings::setUseGlobalSettings(bool useGlobal)
371 {
372 m_useGlobalSettings = useGlobal;
373 saveSettings();
374 emit ClangdSettings::instance().changed();
375 }
376
loadSettings()377 void ClangdProjectSettings::loadSettings()
378 {
379 if (!m_project)
380 return;
381 const QVariantMap data = m_project->namedSettings(clangdSettingsKey()).toMap();
382 m_useGlobalSettings = data.value(clangdUseGlobalSettingsKey(), true).toBool();
383 if (!m_useGlobalSettings)
384 m_customSettings.fromMap(data);
385 }
386
saveSettings()387 void ClangdProjectSettings::saveSettings()
388 {
389 if (!m_project)
390 return;
391 QVariantMap data;
392 if (!m_useGlobalSettings)
393 data = m_customSettings.toMap();
394 data.insert(clangdUseGlobalSettingsKey(), m_useGlobalSettings);
395 m_project->setNamedSettings(clangdSettingsKey(), data);
396 }
397
toMap() const398 QVariantMap ClangdSettings::Data::toMap() const
399 {
400 QVariantMap map;
401 map.insert(useClangdKey(), useClangd);
402 map.insert(clangdPathKey(), executableFilePath.toString());
403 map.insert(clangdIndexingKey(), enableIndexing);
404 map.insert(clangdThreadLimitKey(), workerThreadLimit);
405 return map;
406 }
407
fromMap(const QVariantMap & map)408 void ClangdSettings::Data::fromMap(const QVariantMap &map)
409 {
410 useClangd = map.value(useClangdKey(), false).toBool();
411 executableFilePath = FilePath::fromString(map.value(clangdPathKey()).toString());
412 enableIndexing = map.value(clangdIndexingKey(), true).toBool();
413 workerThreadLimit = map.value(clangdThreadLimitKey(), 0).toInt();
414 }
415