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

265 lines
10 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"
#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 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
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: 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>
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>
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;
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;
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 ClangBackEnd::V2::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
{
projectPart.files.push_back(header1ProjectFile);
projectPart.files.push_back(header2ProjectFile);
projectPart.files.push_back(source1ProjectFile);
projectPart.files.push_back(source2ProjectFile);
projectPart.displayName = QString(projectPartId);
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
projectPart.projectMacros = {{"FOO", "2"}, {"BAR", "1"}};
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
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);
projectPart2.displayName = QString(projectPartId2);
projectPart2.projectMacros = {{"BAR", "1"}, {"FOO", "2"}};
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
Utils::SmallStringVector arguments{ClangPchManager::ProjectUpdater::compilerArguments(
&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
Utils::SmallStringVector arguments2{ClangPchManager::ProjectUpdater::compilerArguments(
&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
expectedContainer = {projectPartId.clone(),
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),
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])},
{filePathIds(sourcePaths)}};
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
expectedContainer2 = {projectPartId2.clone(),
arguments2.clone(),
Utils::clone(compilerMacros),
{},
{filePathId(headerPaths[1])},
{filePathIds(sourcePaths)}};
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};
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
MockPrecompiledHeaderStorage mockPrecompiledHeaderStorage;
ClangPchManager::PchManagerClient pchManagerClient{mockPrecompiledHeaderStorage};
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;
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
ClangPchManager::ProjectUpdater updater{mockPchManagerServer, filePathCache};
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
Utils::SmallString projectPartId{"project1"};
Utils::SmallString projectPartId2{"project2"};
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"};
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::CompilerMacros compilerMacros = {{"BAR", "1"}, {"FOO", "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};
CppTools::ProjectFile source2ProjectFile{QString(sourcePaths[1]), CppTools::ProjectFile::CXXSource};
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;
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};
ClangBackEnd::UpdateProjectPartsMessage message{{expectedContainer.clone(), expectedContainer2.clone()}};
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
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.updateProjectParts(projectParts);
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
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
updater.removeProjectParts({QString(projectPartId), QString(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: 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
{
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
ClangPchManager::PchManagerProjectUpdater pchUpdater{mockPchManagerServer, pchManagerClient, filePathCache};
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}};
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
EXPECT_CALL(mockPrecompiledHeaderStorage, deletePrecompiledHeader(_)).Times(AnyNumber());
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
EXPECT_CALL(mockPchManagerNotifier, precompiledHeaderRemoved(projectPartId.toQString()));
EXPECT_CALL(mockPchManagerNotifier, precompiledHeaderRemoved(projectPartId2.toQString()));
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
pchUpdater.removeProjectParts({QString(projectPartId), QString(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)
{
auto containers = updater.toProjectPartContainers({&projectPart, &projectPart});
ASSERT_THAT(containers, SizeIs(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, 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
{
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 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
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(paths, ElementsAre(CompilerMacro{"BAR", "1"},
CompilerMacro{"FOO", "2"},
CompilerMacro{"DEFINE", "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
}
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
{
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 includePath{"/to/path1", ProjectExplorer::IncludePathType::User};
ProjectExplorer::HeaderPath includePath2{"/to/path2", ProjectExplorer::IncludePathType::User};
ProjectExplorer::HeaderPath invalidPath;
ProjectExplorer::HeaderPath frameworkPath{"/framework/path", ProjectExplorer::IncludePathType::Framework};
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
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 paths = updater.createIncludeSearchPaths({frameworkPath, includePath2, includePath, invalidPath});
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
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(paths, ElementsAre(includePath.path, includePath2.path, frameworkPath.path));
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: 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
}
Copy Permalink