feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
199746143a4f4d87af2d87b7be3ac1228589edbe
qt-creator/tests/unit/unittest/projectupdater-test.cpp

493 lines
22 KiB
C++
Raw Normal View History

Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#include "googletest.h"
Clang: Bulk add project file paths to database This project part container generation because there is not anymore one single access to the database for every file path. Change-Id: I5f82022262fe89a976729d48ee4f098b74a1e1d1 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-08 14:47:33 +02:00
#include "mockfilepathcaching.h"
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include "mockpchmanagerclient.h"
#include "mockpchmanagernotifier.h"
#include "mockpchmanagerserver.h"
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
#include "mockprecompiledheaderstorage.h"
Clang: Add progress bars for creating PCHs and indexing Task-number: QTCREATORBUG-21112 Change-Id: Ie0c00a58f479a2fe7cbc7322490808509733ff0f Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-09-27 17:52:44 +02:00
#include "mockprogressmanager.h"
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
#include "mockprojectpartsstorage.h"
#include "mocksqlitetransactionbackend.h"
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
#include <pchmanagerprojectupdater.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
#include <clangindexingprojectsettings.h>
#include <clangindexingsettingsmanager.h>
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
#include <filepathcaching.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include <pchmanagerclient.h>
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
#include <precompiledheaderstorage.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include <precompiledheadersupdatedmessage.h>
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
#include <projectpartsstorage.h>
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
#include <refactoringdatabaseinitializer.h>
ClangRefactoring: Move generated files to own messages There must be a management about it but this will be added in a different change set. Change-Id: I47b6ce7f671f1c8ae07083d6d99c534069e3cc1a Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-06 19:14:00 +02:00
#include <removegeneratedfilesmessage.h>
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
#include <removeprojectpartsmessage.h>
ClangRefactoring: Move generated files to own messages There must be a management about it but this will be added in a different change set. Change-Id: I47b6ce7f671f1c8ae07083d6d99c534069e3cc1a Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-06 19:14:00 +02:00
#include <updategeneratedfilesmessage.h>
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
#include <updateprojectpartsmessage.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
CppTools: merge CompilerOptionsBuilder with Clang one Since it's never used for other compilers. Change-Id: I9512692d1dc9f9a701ea2453b7d50005478bed5d Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-09-27 10:32:52 +02:00
#include <cpptools/compileroptionsbuilder.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
#include <cpptools/projectpart.h>
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
#include <projectexplorer/project.h>
#include <projectexplorer/projectexplorerconstants.h>
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
#include <utils/algorithm.h>
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
#include <utils/namevalueitem.h>
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
namespace {
using testing::_;
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
using testing::ElementsAre;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
using testing::SizeIs;
using testing::NiceMock;
using testing::AnyNumber;
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
using ClangBackEnd::CompilerMacro;
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
using ClangBackEnd::IncludeSearchPath;
using ClangBackEnd::IncludeSearchPathType;
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
using ClangBackEnd::V2::FileContainer;
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
using ClangBackEnd::ProjectPartContainer;
CppTools: merge CompilerOptionsBuilder with Clang one Since it's never used for other compilers. Change-Id: I9512692d1dc9f9a701ea2453b7d50005478bed5d Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-09-27 10:32:52 +02:00
using CppTools::CompilerOptionsBuilder;
Add system include path to HeaderPath and merge ProjectPartHeaderPath System include paths are appended after other includes by the compiler. So we should set them as system includes and not as normal includes. Otherwise we change the include order. Headers in system include paths are not cluttering the screen with unwanted warning and by the way improve performance too. ProjectPartHeaderPath was a dopperganger of HeaderPath, so we merged them. Change-Id: I7c394b4098b697de79761499ffcd5913cc02d652 Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
2018-09-03 16:10:43 +02:00
using ProjectExplorer::HeaderPath;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
class ProjectUpdater : public testing::Test
{
protected:
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
ClangBackEnd::FilePathId filePathId(Utils::SmallStringView path)
{
return filePathCache.filePathId(ClangBackEnd::FilePathView{path});
}
ClangBackEnd::FilePathIds filePathIds(const Utils::PathStringVector &paths)
{
return filePathCache.filePathIds(Utils::transform(paths, [] (const Utils::PathString &path) {
return ClangBackEnd::FilePathView(path);
}));
}
void SetUp() override
{
Fix projectupdater unit test Amends 35fa8aa8029. Change-Id: Ic791959c4bce66bf9b8b1b43e60c86268c33a029 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-06-17 14:34:37 +02:00
project.rootProjectDirectoryPath = Utils::FilePath::fromString("project");
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
projectPart.project = &project;
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
projectPart.files.push_back(header1ProjectFile);
projectPart.files.push_back(header2ProjectFile);
projectPart.files.push_back(source1ProjectFile);
projectPart.files.push_back(source2ProjectFile);
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
projectPart.files.push_back(nonActiveProjectFile);
Clang: Reuse thread based pipeline for pch creation The pch creation so far used signal and slots but there was no explicit pipeline. This patch is introducing the same architecture like the refactoring plugin. It is filtering out older project parts from the pipeline. Change-Id: Iaa6bd2ca1272231b97ebe1f5f7b2ce8e43bc590c Task-number: QTCREATORBUG-21111 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-09-11 17:02:45 +02:00
projectPart.displayName = "projectb";
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
projectPart.projectMacros = {{"FOO", "2"}, {"BAR", "1"}, {"POO", "3"}};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
projectPartId = projectPartsStorage.fetchProjectPartId(Utils::SmallString{projectPart.id()});
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
projectPart2.project = &project;
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
projectPart2.files.push_back(header2ProjectFile);
projectPart2.files.push_back(header1ProjectFile);
projectPart2.files.push_back(source2ProjectFile);
projectPart2.files.push_back(source1ProjectFile);
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
projectPart2.files.push_back(nonActiveProjectFile);
Clang: Reuse thread based pipeline for pch creation The pch creation so far used signal and slots but there was no explicit pipeline. This patch is introducing the same architecture like the refactoring plugin. It is filtering out older project parts from the pipeline. Change-Id: Iaa6bd2ca1272231b97ebe1f5f7b2ce8e43bc590c Task-number: QTCREATORBUG-21111 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-09-11 17:02:45 +02:00
projectPart2.displayName = "projectaa";
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
projectPart2.projectMacros = {{"BAR", "1"}, {"FOO", "2"}};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
projectPartId2 = projectPartsStorage.fetchProjectPartId(Utils::SmallString{projectPart2.id()});
ClangRefactoring: Fix project part id We used display name which is part of project part id instead of the id getter. Change-Id: I97aa343c4380f9eb8c8e6a4400156eeac1f40863 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-09-10 17:47:42 +02:00
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
nonBuildingProjectPart.files.push_back(cannotBuildSourceProjectFile);
nonBuildingProjectPart.displayName = "nonbuilding";
nonBuildingProjectPart.selectedForBuilding = false;
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
Utils::SmallStringVector arguments{
ClangPchManager::ProjectUpdater::toolChainArguments(&projectPart)};
Utils::SmallStringVector arguments2{
ClangPchManager::ProjectUpdater::toolChainArguments(&projectPart2)};
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
expectedContainer = {projectPartId,
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
arguments.clone(),
Clang: Introduce CompilerMacro We want not only the name but the value of the macro too. So we can compare if anything has changed. Change-Id: Ie59caf8cbf54d108f9e15299d25306a406b5c40d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-06 19:03:14 +01:00
Utils::clone(compilerMacros),
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
{{"project/.pre_includes", 1, ClangBackEnd::IncludeSearchPathType::System},
{CLANG_RESOURCE_DIR, 2, ClangBackEnd::IncludeSearchPathType::BuiltIn}},
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
{},
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
{filePathId(headerPaths[1])},
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
{filePathIds(sourcePaths)},
Utils::Language::Cxx,
Utils::LanguageVersion::LatestCxx,
Utils::LanguageExtension::None};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
expectedContainer2 = {projectPartId2,
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
arguments2.clone(),
Utils::clone(compilerMacros),
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
{{"project/.pre_includes", 1, ClangBackEnd::IncludeSearchPathType::System},
{CLANG_RESOURCE_DIR, 2, ClangBackEnd::IncludeSearchPathType::BuiltIn}},
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
{},
{filePathId(headerPaths[1])},
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
{filePathIds(sourcePaths)},
Utils::Language::Cxx,
Utils::LanguageVersion::LatestCxx,
Utils::LanguageExtension::None};
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
auto settings = settingsManager.settings(&project);
settings->saveMacros({{"POO", "3", Utils::NameValueItem::Unset}});
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
}
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
protected:
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> initializer{database};
ClangBackEnd::FilePathCaching filePathCache{database};
ClangPchManager: Show extra progress for dependency building Task-number: QTCREATORBUG-21956 Change-Id: Id244c9ef9fc7825489daa143b21fcca78164d8c7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-02-19 20:46:08 +01:00
NiceMock<MockProgressManager> mockPchCreationProgressManager;
NiceMock<MockProgressManager> mockDependencyCreationProgressManager;
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
ClangBackEnd::ProjectPartsStorage<Sqlite::Database> projectPartsStorage{database};
ClangPchManager: Show extra progress for dependency building Task-number: QTCREATORBUG-21956 Change-Id: Id244c9ef9fc7825489daa143b21fcca78164d8c7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-02-19 20:46:08 +01:00
ClangPchManager::PchManagerClient pchManagerClient{mockPchCreationProgressManager,
mockDependencyCreationProgressManager};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
MockPchManagerNotifier mockPchManagerNotifier{pchManagerClient};
NiceMock<MockPchManagerServer> mockPchManagerServer;
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
ClangPchManager::ClangIndexingSettingsManager settingsManager;
ClangPchManager::ProjectUpdater updater{mockPchManagerServer,
filePathCache,
projectPartsStorage,
settingsManager};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
ClangBackEnd::ProjectPartId projectPartId;
ClangBackEnd::ProjectPartId projectPartId2;
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
Utils::PathStringVector headerPaths = {"/path/to/header1.h", "/path/to/header2.h"};
Utils::PathStringVector sourcePaths = {"/path/to/source1.cpp", "/path/to/source2.cpp"};
ClangPchManager: Add UsedMacroFilter The compiler macros are filtered in system and project macros. Not used ones are removed. The original order of the macros is retained. Task-number: QTCREATORBUG-21548 Change-Id: Ic9265866bde033e6a9600f9e6439b1697ab73422 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-11-21 20:11:07 +01:00
ClangBackEnd::CompilerMacros compilerMacros = {{"BAR", "1", 1}, {"FOO", "2", 2}};
Utils: Convert to SmallStringView for comparison Change-Id: I38d9716225b81091e8e75b26c9c2258a2aefa987 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-29 12:54:10 +02:00
CppTools::ProjectFile header1ProjectFile{QString(headerPaths[0]), CppTools::ProjectFile::CXXHeader};
CppTools::ProjectFile header2ProjectFile{QString(headerPaths[1]), CppTools::ProjectFile::CXXHeader};
CppTools::ProjectFile source1ProjectFile{QString(sourcePaths[0]), CppTools::ProjectFile::CXXSource};
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
CppTools::ProjectFile source2ProjectFile{QString(sourcePaths[1]),
CppTools::ProjectFile::CXXSource};
CppTools::ProjectFile cannotBuildSourceProjectFile{QString("/cannot/build"),
CppTools::ProjectFile::CXXSource};
CppTools::ProjectFile nonActiveProjectFile{QString("/foo"), CppTools::ProjectFile::CXXSource, false};
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
ProjectExplorer::Project project;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
CppTools::ProjectPart projectPart;
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
CppTools::ProjectPart projectPart2;
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
CppTools::ProjectPart nonBuildingProjectPart;
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
ProjectPartContainer expectedContainer;
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
ProjectPartContainer expectedContainer2;
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
FileContainer generatedFile{{"/path/to", "header1.h"}, "content", {}};
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
FileContainer generatedFile2{{"/path/to2", "header1.h"}, "content", {}};
FileContainer generatedFile3{{"/path/to", "header2.h"}, "content", {}};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
};
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
TEST_F(ProjectUpdater, CallUpdateProjectParts)
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
{
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
std::vector<CppTools::ProjectPart*> projectParts = {&projectPart2, &projectPart};
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
ClangBackEnd::UpdateProjectPartsMessage message{
{expectedContainer.clone(), expectedContainer2.clone()}, {"toolChainArgument"}};
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
updater.updateGeneratedFiles({generatedFile});
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
EXPECT_CALL(mockPchManagerServer, updateProjectParts(message));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
updater.updateProjectParts(projectParts, {"toolChainArgument"});
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
TEST_F(ProjectUpdater, CallUpdateGeneratedFilesWithSortedEntries)
ClangRefactoring: Move generated files to own messages There must be a management about it but this will be added in a different change set. Change-Id: I47b6ce7f671f1c8ae07083d6d99c534069e3cc1a Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-06 19:14:00 +02:00
{
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
ClangBackEnd::UpdateGeneratedFilesMessage message{{generatedFile, generatedFile3, generatedFile2}};
ClangRefactoring: Move generated files to own messages There must be a management about it but this will be added in a different change set. Change-Id: I47b6ce7f671f1c8ae07083d6d99c534069e3cc1a Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-06 19:14:00 +02:00
EXPECT_CALL(mockPchManagerServer, updateGeneratedFiles(message));
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
updater.updateGeneratedFiles({generatedFile2, generatedFile3, generatedFile});
}
TEST_F(ProjectUpdater, GeneratedFilesAddedAreSorted)
{
updater.updateGeneratedFiles({generatedFile2, generatedFile3, generatedFile});
ASSERT_THAT(updater.generatedFiles().fileContainers(),
ElementsAre(generatedFile, generatedFile3, generatedFile2));
}
TEST_F(ProjectUpdater, GeneratedFilesAddedToExcludePaths)
{
updater.updateGeneratedFiles({generatedFile2, generatedFile3, generatedFile});
ASSERT_THAT(updater.excludedPaths(), ElementsAre(generatedFile.filePath,
generatedFile3.filePath,
generatedFile2.filePath));
}
TEST_F(ProjectUpdater, CallRemoveGeneratedFiles)
{
ClangBackEnd::RemoveGeneratedFilesMessage message{{{"/path/to/header1.h"}}};
EXPECT_CALL(mockPchManagerServer, removeGeneratedFiles(message));
updater.removeGeneratedFiles({{"/path/to/header1.h"}});
}
TEST_F(ProjectUpdater, GeneratedFilesRemovedFromExcludePaths)
{
updater.updateGeneratedFiles({generatedFile});
updater.removeGeneratedFiles({generatedFile.filePath});
ASSERT_THAT(updater.excludedPaths(), IsEmpty());
ClangRefactoring: Move generated files to own messages There must be a management about it but this will be added in a different change set. Change-Id: I47b6ce7f671f1c8ae07083d6d99c534069e3cc1a Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-06 19:14:00 +02:00
}
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
TEST_F(ProjectUpdater, CallRemoveProjectParts)
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
{
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
ClangBackEnd::RemoveProjectPartsMessage message{{projectPartId, projectPartId2}};
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
EXPECT_CALL(mockPchManagerServer, removeProjectParts(message));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
updater.removeProjectParts({projectPartId2, projectPartId});
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
Clang: Add Symbol Indexing It is a first step and now a database is generated if you start QtCreator. Some code is now shared with the PchManager which can be improved in the future. Change-Id: Ic267fe7960f6c455d91832859a673ce98f269aa2 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-08-17 12:44:52 +02:00
TEST_F(ProjectUpdater, CallPrecompiledHeaderRemovedInPchManagerProjectUpdater)
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
{
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
ClangPchManager::ClangIndexingSettingsManager settingManager;
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
ClangPchManager::PchManagerProjectUpdater pchUpdater{mockPchManagerServer,
pchManagerClient,
filePathCache,
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
projectPartsStorage,
settingManager};
Clang: Use PCHs for indexing As generating the AST is quite expensive it would be very useful to cache the not changed include. So we generate PCHs for include outside of a project part. With this change this PCHs are used by the indexer. For that they are save to the symbol database by the PCH manager and when fetched by the symbol indexer. Change-Id: I7a5b07cfb32d72d50dc52d2b108cd41727a7bfc7 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-20 12:43:05 +01:00
ClangBackEnd::RemoveProjectPartsMessage message{{projectPartId, projectPartId2}};
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
EXPECT_CALL(mockPchManagerNotifier, precompiledHeaderRemoved(projectPartId));
EXPECT_CALL(mockPchManagerNotifier, precompiledHeaderRemoved(projectPartId2));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
pchUpdater.removeProjectParts({projectPartId, projectPartId2});
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
TEST_F(ProjectUpdater, ConvertProjectPartToProjectPartContainer)
{
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
updater.setExcludedPaths({"/path/to/header1.h"});
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
auto container = updater.toProjectPartContainer(&projectPart);
ASSERT_THAT(container, expectedContainer);
}
TEST_F(ProjectUpdater, ConvertProjectPartToProjectPartContainersHaveSameSizeLikeProjectParts)
{
ClangPchManager: Do not build pch and index inactive project parts Some project parts should not be built as well as some files can be inactive inside project part. We should not try to build pch-s or index them. Change-Id: I8e62365b817a424ae38a0df94b6703820a4cde9d Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-02-15 16:15:01 +01:00
auto containers = updater.toProjectPartContainers(
{&projectPart, &projectPart, &nonBuildingProjectPart});
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
ASSERT_THAT(containers, SizeIs(2));
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectUpdater, CallStorageInsideTransaction)
{
InSequence s;
CppTools::ProjectPart projectPart;
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
projectPart.project = &project;
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
projectPart.displayName = "project";
Utils::SmallString projectPartName = projectPart.id();
MockSqliteTransactionBackend mockSqliteTransactionBackend;
MockProjectPartsStorage mockProjectPartsStorage;
ON_CALL(mockProjectPartsStorage, transactionBackend())
.WillByDefault(ReturnRef(mockSqliteTransactionBackend));
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
ClangPchManager::ClangIndexingSettingsManager settingsManager;
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
ClangPchManager::ProjectUpdater updater{mockPchManagerServer,
filePathCache,
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
mockProjectPartsStorage,
settingsManager};
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
EXPECT_CALL(mockProjectPartsStorage, fetchProjectPartId(Eq(projectPartName)));
updater.toProjectPartContainers({&projectPart});
}
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
TEST_F(ProjectUpdater, CreateSortedExcludedPaths)
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
{
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
auto excludedPaths = updater.createExcludedPaths({generatedFile2, generatedFile3, generatedFile});
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
ASSERT_THAT(excludedPaths, ElementsAre(ClangBackEnd::FilePath{"/path/to/header1.h"},
ClangBackEnd::FilePath{"/path/to/header2.h"},
ClangBackEnd::FilePath{"/path/to2/header1.h"}));
Clang: Handle generated files We don't handled generated files so we got internal parse errors. Change-Id: If75e202f93fe3f71f43e3b1d15c0fb77e20c2248 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-02-01 13:43:28 +01:00
}
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
TEST_F(ProjectUpdater, CreateSortedCompilerMacros)
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
{
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
auto paths = updater.createCompilerMacros({{"DEFINE", "1"}, {"FOO", "2"}, {"BAR", "1"}}, {});
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
ClangPchManager: Add UsedMacroFilter The compiler macros are filtered in system and project macros. Not used ones are removed. The original order of the macros is retained. Task-number: QTCREATORBUG-21548 Change-Id: Ic9265866bde033e6a9600f9e6439b1697ab73422 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-11-21 20:11:07 +01:00
ASSERT_THAT(paths, ElementsAre(CompilerMacro{"BAR", "1", 1},
CompilerMacro{"FOO", "2", 2},
CompilerMacro{"DEFINE", "1", 3}));
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
}
Clang: Filter macro QT_TESTCASE_BUILDDIR out We have to universalize it later with a UI so that user can set their own macros. Change-Id: I5385c3c1b01dbf77a1cbc2431103fcdea3f96118 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io> Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2019-05-06 15:58:39 +02:00
TEST_F(ProjectUpdater, FilterCompilerMacros)
{
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
auto paths = updater.createCompilerMacros({{"DEFINE", "1"},
{"QT_TESTCASE_BUILDDIR", "2"},
{"BAR", "1"}},
{});
Clang: Filter macro QT_TESTCASE_BUILDDIR out We have to universalize it later with a UI so that user can set their own macros. Change-Id: I5385c3c1b01dbf77a1cbc2431103fcdea3f96118 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io> Reviewed-by: Cristian Adam <cristian.adam@qt.io>
2019-05-06 15:58:39 +02:00
ASSERT_THAT(paths, ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"DEFINE", "1", 3}));
}
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
TEST_F(ProjectUpdater, FilterSettingsMacros)
{
auto paths = updater.createCompilerMacros({{"YI", "1"}, {"SAN", "3"}, {"SE", "4"}, {"WU", "5"}},
{{"SE", "44", Utils::NameValueItem::Unset},
Unittest: Fix compile Change-Id: I2ee07a67f042ac952d0301a0880f0674d21de714 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2019-07-24 11:14:37 +02:00
{"ER", "2", Utils::NameValueItem::SetEnabled},
Enable macro editing for the Clang indexer Refactor much of the code from Environment* classes to NameValue* classes to share it with the preprocessor macro settings. Change-Id: Ica4ee817aa338230c422b30d91240d266248d226 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-05-07 16:51:22 +02:00
{"WU", "5", Utils::NameValueItem::Unset}});
ASSERT_THAT(paths,
ElementsAre(CompilerMacro{"ER", "2", 3},
CompilerMacro{"SE", "4", 3},
CompilerMacro{"YI", "1", 1},
CompilerMacro{"SAN", "3", 2}));
}
ClangRefactoring: Integrate generated files This is an intermediate step to handle the indexing of the project parts completely. The generated files are now independently handled from the project parts. We still not handle the case the a file is indexed but the generated file is not provided. This will be done in a different patch. All provided data is now sorted too to improve merging. Change-Id: I09712b99217a881ec0a233d09aea8659fb787324 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-08-07 19:01:01 +02:00
TEST_F(ProjectUpdater, CreateSortedIncludeSearchPaths)
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
{
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
CppTools::ProjectPart projectPart;
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
projectPart.project = &project;
ProjectExplorer: Rename IncludePathType to HeaderPathType It is the type used by the HeaderPath class, so reflect that in the name. I also considered to rename HeaderPath to IncludePath, but that name is reflected in a lot of users, which would also need to be adjusted for consistency. That would blow up the patch size for little value IMHO. Change-Id: I51421dbd3ab8b2874dc32fc82dc394c9b93ce5e9 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2018-09-13 11:44:43 +02:00
ProjectExplorer::HeaderPath includePath{"/to/path1", ProjectExplorer::HeaderPathType::User};
ProjectExplorer::HeaderPath includePath2{"/to/path2", ProjectExplorer::HeaderPathType::User};
Add system include path to HeaderPath and merge ProjectPartHeaderPath System include paths are appended after other includes by the compiler. So we should set them as system includes and not as normal includes. Otherwise we change the include order. Headers in system include paths are not cluttering the screen with unwanted warning and by the way improve performance too. ProjectPartHeaderPath was a dopperganger of HeaderPath, so we merged them. Change-Id: I7c394b4098b697de79761499ffcd5913cc02d652 Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
2018-09-03 16:10:43 +02:00
ProjectExplorer::HeaderPath invalidPath;
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
ProjectExplorer::HeaderPath frameworkPath{"/framework/path",
ProjectExplorer::HeaderPathType::Framework};
ProjectExplorer::HeaderPath builtInPath{"/builtin/path", ProjectExplorer::HeaderPathType::BuiltIn};
ProjectExplorer::HeaderPath systemPath{"/system/path", ProjectExplorer::HeaderPathType::System};
projectPart.headerPaths = {
systemPath, builtInPath, frameworkPath, includePath2, includePath, invalidPath};
auto paths = updater.createIncludeSearchPaths(projectPart);
CppTools: Add pre system include search path per project Sometimes you want add a pre system include search path per project to overload some system header for indexing. This can then even be checked in the repository. Change-Id: Ib103e5935d0553aa94522ed736f8c4eb2405a093 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-04-07 20:46:06 +02:00
ASSERT_THAT(
paths.system,
ElementsAre(Eq(IncludeSearchPath{systemPath.path, 2, IncludeSearchPathType::System}),
Eq(IncludeSearchPath{builtInPath.path, 5, IncludeSearchPathType::BuiltIn}),
Eq(IncludeSearchPath{frameworkPath.path, 3, IncludeSearchPathType::Framework}),
Eq(IncludeSearchPath{"project/.pre_includes", 1, IncludeSearchPathType::System}),
Eq(IncludeSearchPath{CLANG_RESOURCE_DIR,
4,
ClangBackEnd::IncludeSearchPathType::BuiltIn})));
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
ASSERT_THAT(paths.project,
ElementsAre(Eq(IncludeSearchPath{includePath.path, 2, IncludeSearchPathType::User}),
Eq(IncludeSearchPath{includePath2.path, 1, IncludeSearchPathType::User})));
}
TEST_F(ProjectUpdater, ToolChainArguments)
{
projectPart.toolChainTargetTriple = "target";
projectPart.extraCodeModelFlags.push_back("extraflags");
projectPart.compilerFlags.push_back("-fPIC");
projectPart.projectConfigFile = "config.h";
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
auto arguments = updater.toolChainArguments(&projectPart);
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
ASSERT_THAT(arguments,
UnitTests: More QString fixes Change-Id: Id1c60dfa8b3ada2c855f43437a153042cfec9f63 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-04-04 15:50:11 +02:00
ElementsAre(QString{"-m32"},
QString{"extraflags"},
QString{"-include"},
QString{"config.h"}));
PchManager: Split pch tasks in project and system pch tasks Like you can see in the task numbers this patch is touching many different areas. So I will only touch the main parts. It is using a clang action instead of an extra process which will be enabling the handling of generated files in PCHs. The flags from the project part are now not anymore transformed in a command line but they are saved in the container semantically aware so that they can later be merged. Most of this patch is simply polishing of other patches. Task-number: QTCREATORBUG-21346 Task-number: QTCREATORBUG-21380 Task-number: QTCREATORBUG-21382 Task-number: QTCREATORBUG-21383 Task-number: QTCREATORBUG-21693 Task-number: QTCREATORBUG-21778 Change-Id: I9b0c02d8149b554254e819448fbc61eeaa5b7494 Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-12-17 12:06:57 +01:00
}
TEST_F(ProjectUpdater, ToolChainArgumentsMSVC)
{
projectPart.toolChainTargetTriple = "target";
projectPart.extraCodeModelFlags.push_back("extraflags");
projectPart.toolchainType = ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
projectPart.isMsvc2015Toolchain = true;
auto arguments = updater.toolChainArguments(&projectPart);
ASSERT_THAT(arguments,
UnitTests: More QString fixes Change-Id: Id1c60dfa8b3ada2c855f43437a153042cfec9f63 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-04-04 15:50:11 +02:00
ElementsAre(QString{"-m32"},
QString{"extraflags"},
QString{"-U__clang__"},
QString{"-U__clang_major__"},
QString{"-U__clang_minor__"},
QString{"-U__clang_patchlevel__"},
QString{"-U__clang_version__"},
QString{"-U__cpp_aggregate_bases"},
QString{"-U__cpp_aggregate_nsdmi"},
QString{"-U__cpp_alias_templates"},
QString{"-U__cpp_aligned_new"},
QString{"-U__cpp_attributes"},
QString{"-U__cpp_binary_literals"},
QString{"-U__cpp_capture_star_this"},
QString{"-U__cpp_constexpr"},
QString{"-U__cpp_decltype"},
QString{"-U__cpp_decltype_auto"},
QString{"-U__cpp_deduction_guides"},
QString{"-U__cpp_delegating_constructors"},
QString{"-U__cpp_digit_separators"},
QString{"-U__cpp_enumerator_attributes"},
QString{"-U__cpp_exceptions"},
QString{"-U__cpp_fold_expressions"},
QString{"-U__cpp_generic_lambdas"},
QString{"-U__cpp_guaranteed_copy_elision"},
QString{"-U__cpp_hex_float"},
QString{"-U__cpp_if_constexpr"},
Clang: Fix build with clang-8 Clang-Tidy checks and Clazy flags updated. CLANG-UPGRADE-CHECK done. Change-Id: I1ca585c5c3c77a7f183719df9c262603150914e8 Reviewed-by: Alessandro Portale <alessandro.portale@qt.io> Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2019-04-04 14:50:10 +02:00
QString{"-U__cpp_impl_destroying_delete"},
UnitTests: More QString fixes Change-Id: Id1c60dfa8b3ada2c855f43437a153042cfec9f63 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-04-04 15:50:11 +02:00
QString{"-U__cpp_inheriting_constructors"},
QString{"-U__cpp_init_captures"},
QString{"-U__cpp_initializer_lists"},
QString{"-U__cpp_inline_variables"},
QString{"-U__cpp_lambdas"},
QString{"-U__cpp_namespace_attributes"},
QString{"-U__cpp_nested_namespace_definitions"},
QString{"-U__cpp_noexcept_function_type"},
QString{"-U__cpp_nontype_template_args"},
QString{"-U__cpp_nontype_template_parameter_auto"},
QString{"-U__cpp_nsdmi"},
QString{"-U__cpp_range_based_for"},
QString{"-U__cpp_raw_strings"},
QString{"-U__cpp_ref_qualifiers"},
QString{"-U__cpp_return_type_deduction"},
QString{"-U__cpp_rtti"},
QString{"-U__cpp_rvalue_references"},
QString{"-U__cpp_static_assert"},
QString{"-U__cpp_structured_bindings"},
QString{"-U__cpp_template_auto"},
QString{"-U__cpp_threadsafe_static_init"},
QString{"-U__cpp_unicode_characters"},
QString{"-U__cpp_unicode_literals"},
QString{"-U__cpp_user_defined_literals"},
QString{"-U__cpp_variable_templates"},
QString{"-U__cpp_variadic_templates"},
QString{"-U__cpp_variadic_using"}));
Clang: Check if the include search path has changed If the include search paths and the compiler macros have not changed it is save to assume that we don't need to update the symbol database. This saves us from executing a very expensive task. Later we have to test the modification time of the files too. Change-Id: I6b958075024a811c2abd3d7918263fd74bba090b Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-02-08 12:48:46 +01:00
}
Clang: On the road to update and preprocessor support This patch has grown in a quite big change set and it is really hard to divide it in different parts. V2::ProjectPartContainer is now using FileIds instead of file paths. This cleans code up because it is a big step in the direction that internally only file ids are used. But it is depending on the file cache, so the file cache has to be provided as an argument. There is now an interface for transactions too which are ease the testing of them and enables the support of preprocessor. It adds macros as symbols and is saving used macros. The used macro support is enabling update improvements because only if a changed macro is used it needs to be recompiled. This is still in flux and can be changed in later patches. Change-Id: I492a2c9af1201d40fdd9f46a0045f7878bbbaa3d Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2018-01-22 14:21:01 +01:00
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
TEST_F(ProjectUpdater, FetchProjectPartName)
{
updater.updateProjectParts({&projectPart}, {});
auto projectPartName = updater.fetchProjectPartName(1);
UnitTests: More QString fixes Change-Id: Id1c60dfa8b3ada2c855f43437a153042cfec9f63 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2019-04-04 15:50:11 +02:00
ASSERT_THAT(projectPartName, Eq(QString{" projectb"}));
Clang: Add ClangPchManager Compiling every header file again and again is quite time comsuming. There are technics to improve this like preambles(a kind of automated precompiled header) but they don't share their data between translation units. This approach provides an automatically generated precompiled header for every project and subproject to improve the loading time. Change-Id: I34f5bd4db21951175920e2a9bbf6b97b1d705969 Reviewed-by: Eike Ziller <eike.ziller@qt.io> Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2017-01-30 11:24:46 +01:00
}
Clang: Bulk add project file paths to database This project part container generation because there is not anymore one single access to the database for every file path. Change-Id: I5f82022262fe89a976729d48ee4f098b74a1e1d1 Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
2019-08-08 14:47:33 +02:00
TEST_F(ProjectUpdater, AddProjectFilesToFilePathCache)
{
NiceMock<MockFilePathCaching> mockFilePathCaching;
ClangPchManager::ProjectUpdater updater{mockPchManagerServer,
mockFilePathCaching,
projectPartsStorage};
EXPECT_CALL(mockFilePathCaching,
addFilePaths(UnorderedElementsAre(Eq(headerPaths[0]),
Eq(headerPaths[1]),
Eq(sourcePaths[0]),
Eq(sourcePaths[1]))));
updater.updateProjectParts({&projectPart}, {});
}
Clang: Improve project part updating The project part ids are now already created very early in the database. This removes some checks because we can assume that an id already exists. The project part are now completely persistent, so we can read them from the database and compare them with new generated from a new creator session. This should help to not recreate the same PCH again and again. Task-number: QTCREATORBUG-21151 Change-Id: Iced818ff9f7431eaed3e37978087cc0a43b9afda Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
2019-03-13 15:09:30 +01:00
// test for update many time and get the same id
} // namespace
Copy Permalink