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

C++: fix include/framework path handling.

Browse Source 
Instead of having two lists of paths, now only one list is used where
both include paths and framework paths can be mixed. This reflects the
way the compiler is invoked, and retains the (correct) search order.

Task-number: QTCREATORBUG-11599
Change-Id: I373953e3e305df5b7a0d10920e12d146584adf9f
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@digia.com>
This commit is contained in:
Erik Verbruggen
2014-06-25 17:23:19 +02:00
parent 76152088e9
commit 3d33886e53
32 changed files with 353 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plugins/autotoolsprojectmanager/autotoolsproject.cpp
+4 -1
View File
@@ -427,7 +427,10 @@ void AutotoolsProject::updateCppCodeModel()
foreach (const QString &file, m_files)
part->files << CppTools::ProjectFile(file, CppTools::ProjectFile::CXXSource);
part->includePaths += m_makefileParserThread->includePaths();
foreach (const QString &inc, m_makefileParserThread->includePaths()) {
part->headerPaths += CppTools::ProjectPart::HeaderPath(
inc, CppTools::ProjectPart::HeaderPath::IncludePath);
}
part->projectDefines += m_makefileParserThread->defines();
pinfo.appendProjectPart(part);
src/plugins/clangcodemodel/clangcompletion.cpp
+15 -24
View File
@@ -213,7 +213,8 @@ IAssistInterface *ClangCompletionAssistProvider::createAssistInterface(
QList<ProjectPart::Ptr> parts = modelManager->projectPart(fileName);
if (parts.isEmpty())
parts += modelManager->fallbackProjectPart();
QStringList includePaths, frameworkPaths, options;
ProjectPart::HeaderPaths headerPaths;
QStringList options;
PchInfo::Ptr pchInfo;
foreach (ProjectPart::Ptr part, parts) {
if (part.isNull())
@@ -222,15 +223,14 @@ IAssistInterface *ClangCompletionAssistProvider::createAssistInterface(
pchInfo = PchManager::instance()->pchInfo(part);
if (!pchInfo.isNull())
options.append(ClangCodeModel::Utils::createPCHInclusionOptions(pchInfo->fileName()));
includePaths = part->includePaths;
frameworkPaths = part->frameworkPaths;
headerPaths = part->headerPaths;
break;
}
return new ClangCodeModel::ClangCompletionAssistInterface(
m_clangCompletionWrapper,
document, position, fileName, reason,
options, includePaths, frameworkPaths, pchInfo);
options, headerPaths, pchInfo);
}
// ------------------------
@@ -550,14 +550,12 @@ ClangCompletionAssistInterface::ClangCompletionAssistInterface(ClangCompleter::P
const QString &fileName,
AssistReason reason,
const QStringList &options,
const QStringList &includePaths,
const QStringList &frameworkPaths,
const QList<CppTools::ProjectPart::HeaderPath> &headerPaths,
const PchInfo::Ptr &pchInfo)
: DefaultAssistInterface(document, position, fileName, reason)
, m_clangWrapper(clangWrapper)
, m_options(options)
, m_includePaths(includePaths)
, m_frameworkPaths(frameworkPaths)
, m_headerPaths(headerPaths)
, m_savedPchPointer(pchInfo)
{
Q_ASSERT(!clangWrapper.isNull());
@@ -1138,29 +1136,22 @@ bool ClangCompletionAssistProcessor::completeInclude(const QTextCursor &cursor)
}
// Make completion for all relevant includes
QStringList includePaths = m_interface->includePaths();
const QString &currentFilePath = QFileInfo(m_interface->fileName()).path();
if (!includePaths.contains(currentFilePath))
includePaths.append(currentFilePath);
ProjectPart::HeaderPaths headerPaths = m_interface->headerPaths();
const ProjectPart::HeaderPath currentFilePath(QFileInfo(m_interface->fileName()).path(),
ProjectPart::HeaderPath::IncludePath);
if (!headerPaths.contains(currentFilePath))
headerPaths.append(currentFilePath);
const Core::MimeType mimeType = Core::MimeDatabase::findByType(QLatin1String("text/x-c++hdr"));
const QStringList suffixes = mimeType.suffixes();
foreach (const QString &includePath, includePaths) {
QString realPath = includePath;
foreach (const ProjectPart::HeaderPath &headerPath, headerPaths) {
QString realPath = headerPath.path;
if (!directoryPrefix.isEmpty()) {
realPath += QLatin1Char('/');
realPath += directoryPrefix;
}
completeIncludePath(realPath, suffixes);
}
foreach (const QString &frameworkPath, m_interface->frameworkPaths()) {
QString realPath = frameworkPath;
if (!directoryPrefix.isEmpty()) {
realPath += QLatin1Char('/');
realPath += directoryPrefix;
realPath += QLatin1String(".framework/Headers");
if (headerPath.isFrameworkPath())
realPath += QLatin1String(".framework/Headers");
}
completeIncludePath(realPath, suffixes);
}
src/plugins/clangcodemodel/clangcompletion.h
+6 -8
View File
@@ -35,6 +35,7 @@
#include <cplusplus/Icons.h>
#include <cpptools/cppcompletionassistprovider.h>
#include <cpptools/cppmodelmanagerinterface.h>
#include <texteditor/codeassist/basicproposalitem.h>
#include <texteditor/codeassist/completionassistprovider.h>
@@ -76,8 +77,7 @@ public:
const QString &fileName,
TextEditor::AssistReason reason,
const QStringList &options,
const QStringList &includePaths,
const QStringList &frameworkPaths,
const QList<CppTools::ProjectPart::HeaderPath> &headerPaths,
const Internal::PchInfo::Ptr &pchInfo);
ClangCodeModel::ClangCompleter::Ptr clangWrapper() const
@@ -91,16 +91,14 @@ public:
const QStringList &options() const
{ return m_options; }
const QStringList &includePaths() const
{ return m_includePaths; }
const QStringList &frameworkPaths() const
{ return m_frameworkPaths; }
const QList<CppTools::ProjectPart::HeaderPath> &headerPaths() const
{ return m_headerPaths; }
private:
ClangCodeModel::ClangCompleter::Ptr m_clangWrapper;
ClangCodeModel::Internal::UnsavedFiles m_unsavedFiles;
QStringList m_options, m_includePaths, m_frameworkPaths;
QStringList m_options;
QList<CppTools::ProjectPart::HeaderPath> m_headerPaths;
Internal::PchInfo::Ptr m_savedPchPointer;
};
src/plugins/clangcodemodel/clangutils.cpp
+14 -5
View File
@@ -209,11 +209,20 @@ QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind
result << buildDefines(pPart->toolchainDefines, false);
result << buildDefines(pPart->projectDefines, false);
foreach (const QString &frameworkPath, pPart->frameworkPaths)
result.append(QLatin1String("-F") + frameworkPath);
foreach (const QString &inc, pPart->includePaths)
if (!inc.isEmpty() && !isBlacklisted(inc))
result << (QLatin1String("-I") + inc);
typedef ProjectPart::HeaderPath HeaderPath;
foreach (const HeaderPath &headerPath , pPart->headerPaths) {
if (headerPath.path.isEmpty() || isBlacklisted(headerPath.path))
continue;
QString prefix;
switch (headerPath.type) {
case HeaderPath::IncludePath: prefix = QLatin1String("-I"); break;
case HeaderPath::FrameworkPath: prefix = QLatin1String("-F"); break;
default: Q_UNREACHABLE(); break;
}
result.append(prefix + headerPath.path);
}
#if 0
qDebug() << "--- m_args:";
src/plugins/clangcodemodel/pchmanager.cpp
+7 -10
View File
@@ -249,7 +249,8 @@ void PchManager::doPchInfoUpdateNone(QFutureInterface<void> &future,
void PchManager::doPchInfoUpdateFuzzy(QFutureInterface<void> &future,
const PchManager::UpdateParams params)
{
QHash<QString, QSet<QString> > includes, frameworks;
typedef ProjectPart::HeaderPath HeaderPath;
QHash<QString, QSet<HeaderPath>> headers;
QHash<QString, QSet<QByteArray> > definesPerPCH;
QHash<QString, bool> objc;
QHash<QString, bool> cplusplus;
@@ -266,8 +267,7 @@ void PchManager::doPchInfoUpdateFuzzy(QFutureInterface<void> &future,
continue;
inputToParts[pch].append(projectPart);
includes[pch].unite(QSet<QString>::fromList(projectPart->includePaths));
frameworks[pch].unite(QSet<QString>::fromList(projectPart->frameworkPaths));
headers[pch].unite(QSet<HeaderPath>::fromList(projectPart->headerPaths));
cVersions[pch] = std::max(cVersions.value(pch, ProjectPart::C89), projectPart->cVersion);
cxxVersions[pch] = std::max(cxxVersions.value(pch, ProjectPart::CXX98), projectPart->cxxVersion);
cxxExtensionsMap[pch] = cxxExtensionsMap[pch] | projectPart->cxxExtensions;
@@ -306,8 +306,7 @@ void PchManager::doPchInfoUpdateFuzzy(QFutureInterface<void> &future,
projectPart->cVersion = cVersions[pch];
projectPart->cxxVersion = cxxVersions[pch];
projectPart->cxxExtensions = cxxExtensionsMap[pch];
projectPart->includePaths = includes[pch].toList();
projectPart->frameworkPaths = frameworks[pch].toList();
projectPart->headerPaths = headers[pch].toList();
QList<QByteArray> defines = definesPerPCH[pch].toList();
if (!defines.isEmpty()) {
@@ -378,22 +377,20 @@ void PchManager::doPchInfoUpdateCustom(QFutureInterface<void> &future,
future.setProgressRange(0, 1);
future.setProgressValue(0);
QSet<QString> includes, frameworks;
ProjectPart::HeaderPaths headers;
bool objc = false;
bool cplusplus = false;
ProjectPart::Ptr united(new ProjectPart());
united->cxxVersion = ProjectPart::CXX98;
foreach (const ProjectPart::Ptr &projectPart, params.projectParts) {
includes.unite(QSet<QString>::fromList(projectPart->includePaths));
frameworks.unite(QSet<QString>::fromList(projectPart->frameworkPaths));
headers += projectPart->headerPaths;
united->cVersion = std::max(united->cVersion, projectPart->cVersion);
united->cxxVersion = std::max(united->cxxVersion, projectPart->cxxVersion);
united->qtVersion = std::max(united->qtVersion, projectPart->qtVersion);
objc |= hasObjCFiles(projectPart);
cplusplus |= hasCppFiles(projectPart);
}
united->frameworkPaths = frameworks.toList();
united->includePaths = includes.toList();
united->headerPaths = headers;
QStringList opts = Utils::createClangOptions(
united, getPrefixFileKind(objc, cplusplus));
united.clear();
src/plugins/cmakeprojectmanager/cmakeproject.cpp
+9 -4
View File
@@ -338,27 +338,32 @@ bool CMakeProject::parseCMakeLists()
CppTools::CppModelManagerInterface::ProjectInfo pinfo = modelmanager->projectInfo(this);
pinfo.clearProjectParts();
CppTools::ProjectPart::Ptr part(new CppTools::ProjectPart);
typedef CppTools::ProjectPart ProjectPart;
ProjectPart::Ptr part(new ProjectPart);
part->project = this;
part->displayName = displayName();
part->projectFile = projectFilePath().toString();
// This explicitly adds -I. to the include paths
part->includePaths += projectDirectory().toString();
part->headerPaths += ProjectPart::HeaderPath(projectDirectory().toString(),
ProjectPart::HeaderPath::IncludePath);
foreach (const QString &includeFile, cbpparser.includeFiles()) {
ProjectPart::HeaderPath hp(includeFile, ProjectPart::HeaderPath::IncludePath);
// CodeBlocks is utterly ignorant of frameworks on Mac, and won't report framework
// paths. The work-around is to check if the include path ends in ".framework", and
// if so, add the parent directory as framework path.
if (includeFile.endsWith(QLatin1String(".framework"))) {
const int slashIdx = includeFile.lastIndexOf(QLatin1Char('/'));
if (slashIdx != -1) {
part->frameworkPaths += includeFile.left(slashIdx);
hp = ProjectPart::HeaderPath(includeFile.left(slashIdx),
ProjectPart::HeaderPath::FrameworkPath);
continue;
}
}
part->includePaths += includeFile;
part->headerPaths += hp;
}
part->projectDefines += cbpparser.defines();
src/plugins/cppeditor/cppcodemodelinspectordialog.cpp
+10 -21
View File
@@ -1446,7 +1446,7 @@ void CppCodeModelInspectorDialog::refresh()
}
// Merged entities
dumper.dumpMergedEntities(cmmi->includePaths(), cmmi->frameworkPaths(), cmmi->definedMacros());
dumper.dumpMergedEntities(cmmi->headerPaths(), cmmi->definedMacros());
}
enum DocumentTabs {
@@ -1559,8 +1559,7 @@ enum ProjectPartTabs {
ProjectPartGeneralTab,
ProjectPartFilesTab,
ProjectPartDefinesTab,
ProjectPartIncludePathsTab,
ProjectPartFrameworkPathsTab,
ProjectPartHeaderPathsTab,
ProjectPartPrecompiledHeadersTab
};
@@ -1570,8 +1569,7 @@ static QString partTabName(int tabIndex, int numberOfEntries = -1)
"&General",
"Project &Files",
"&Defines",
"&Include Paths",
"F&ramework Paths",
"&Header Paths",
"Pre&compiled Headers"
};
QString result = QLatin1String(names[tabIndex]);
@@ -1591,13 +1589,9 @@ void CppCodeModelInspectorDialog::clearProjectPartData()
m_ui->partProjectDefinesEdit->setPlainText(QString());
m_ui->projectPartTab->setTabText(ProjectPartDefinesTab, partTabName(ProjectPartDefinesTab));
m_ui->partIncludePathsEdit->setPlainText(QString());
m_ui->projectPartTab->setTabText(ProjectPartIncludePathsTab,
partTabName(ProjectPartIncludePathsTab));
m_ui->partFrameworkPathsEdit->setPlainText(QString());
m_ui->projectPartTab->setTabText(ProjectPartFrameworkPathsTab,
partTabName(ProjectPartFrameworkPathsTab));
m_ui->partHeaderPathsEdit->setPlainText(QString());
m_ui->projectPartTab->setTabText(ProjectPartHeaderPathsTab,
partTabName(ProjectPartHeaderPathsTab));
m_ui->partPrecompiledHeadersEdit->setPlainText(QString());
m_ui->projectPartTab->setTabText(ProjectPartPrecompiledHeadersTab,
@@ -1654,15 +1648,10 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Ptr &
m_ui->projectPartTab->setTabText(ProjectPartDefinesTab,
partTabName(ProjectPartDefinesTab, numberOfDefines));
// Include Paths
m_ui->partIncludePathsEdit->setPlainText(CMI::Utils::pathListToString(part->includePaths));
m_ui->projectPartTab->setTabText(ProjectPartIncludePathsTab,
partTabName(ProjectPartIncludePathsTab, part->includePaths.size()));
// Framework Paths
m_ui->partFrameworkPathsEdit->setPlainText(CMI::Utils::pathListToString(part->frameworkPaths));
m_ui->projectPartTab->setTabText(ProjectPartFrameworkPathsTab,
partTabName(ProjectPartFrameworkPathsTab, part->frameworkPaths.size()));
// Header Paths
m_ui->partHeaderPathsEdit->setPlainText(CMI::Utils::pathListToString(part->headerPaths));
m_ui->projectPartTab->setTabText(ProjectPartHeaderPathsTab,
partTabName(ProjectPartHeaderPathsTab, part->headerPaths.size()));
// Precompiled Headers
m_ui->partPrecompiledHeadersEdit->setPlainText(
src/plugins/cppeditor/cppcodemodelinspectordialog.ui
+2 -16
View File
@@ -261,25 +261,11 @@
</widget>
<widget class="QWidget" name="tab_15">
<attribute name="title">
<string notr="true">&amp;Include Paths</string>
<string notr="true">&amp;Header Paths</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_16">
<item>
<widget class="QPlainTextEdit" name="partIncludePathsEdit">
<property name="readOnly">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="definesTab_2">
<attribute name="title">
<string notr="true">F&amp;ramework Paths</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_17">
<item>
<widget class="QPlainTextEdit" name="partFrameworkPathsEdit">
<widget class="QPlainTextEdit" name="partHeaderPathsEdit">
<property name="readOnly">
<bool>true</bool>
</property>
src/plugins/cppeditor/cppquickfix_test.cpp
+44 -35
View File
@@ -123,11 +123,11 @@ static QString &removeTrailingWhitespace(QString &input)
/// Exactly one TestFile must contain the cursor position marker '@' in the originalSource.
QuickFixTestCase::QuickFixTestCase(const QList<QuickFixTestDocument::Ptr> &theTestFiles,
CppQuickFixFactory *factory,
const QStringList &includePaths,
const ProjectPart::HeaderPaths &headerPaths,
int resultIndex)
: m_testFiles(theTestFiles)
, m_cppCodeStylePreferences(0)
, m_restoreIncludePaths(false)
, m_restoreHeaderPaths(false)
{
QVERIFY(succeededSoFar());
@@ -144,10 +144,10 @@ QuickFixTestCase::QuickFixTestCase(const QList<QuickFixTestDocument::Ptr> &theTe
testFile->writeToDisk();
// Set appropriate include paths
if (!includePaths.isEmpty()) {
m_restoreIncludePaths = true;
m_includePathsToRestore = m_modelManager->includePaths();
m_modelManager->setIncludePaths(includePaths);
if (!headerPaths.isEmpty()) {
m_restoreHeaderPaths = true;
m_headerPathsToRestore = m_modelManager->headerPaths();
m_modelManager->setHeaderPaths(headerPaths);
}
// Update Code Model
@@ -213,14 +213,22 @@ QuickFixTestCase::~QuickFixTestCase()
m_cppCodeStylePreferences->setCurrentDelegate(m_cppCodeStylePreferencesOriginalDelegateId);
// Restore include paths
if (m_restoreIncludePaths)
m_modelManager->setIncludePaths(m_includePathsToRestore);
if (m_restoreHeaderPaths)
m_modelManager->setHeaderPaths(m_headerPathsToRestore);
// Remove created files from file system
foreach (const QuickFixTestDocument::Ptr &testDocument, m_testFiles)
QVERIFY(QFile::remove(testDocument->filePath()));
}
void QuickFixTestCase::run(const QList<QuickFixTestDocument::Ptr> &theTestFiles,
CppQuickFixFactory *factory, const QString &incPath)
{
ProjectPart::HeaderPaths hps;
hps += ProjectPart::HeaderPath(incPath, ProjectPart::HeaderPath::IncludePath);
QuickFixTestCase(theTestFiles, factory, hps);
}
/// Delegates directly to AddIncludeForUndefinedIdentifierOp for easier testing.
class AddIncludeForUndefinedIdentifierTestFactory : public CppQuickFixFactory
{
@@ -1289,7 +1297,7 @@ void CppEditorPlugin::test_quickfix_InsertDefFromDecl_afterClass()
testFiles << QuickFixTestDocument::create("file.cpp", original, expected);
InsertDefFromDecl factory;
QuickFixTestCase(testFiles, &factory, QStringList(), 1);
QuickFixTestCase(testFiles, &factory, ProjectPart::HeaderPaths(), 1);
}
/// Check from header file: If there is a source file, insert the definition in the source file.
@@ -1478,7 +1486,7 @@ void CppEditorPlugin::test_quickfix_InsertDefFromDecl_insideClass()
"};";
InsertDefFromDecl factory;
QuickFixTestCase(singleDocument(original, expected), &factory, QStringList(), 1);
QuickFixTestCase(singleDocument(original, expected), &factory, ProjectPart::HeaderPaths(), 1);
}
/// Check not triggering when definition exists
@@ -1492,7 +1500,8 @@ void CppEditorPlugin::test_quickfix_InsertDefFromDecl_notTriggeringWhenDefinitio
const QByteArray expected = original;
InsertDefFromDecl factory;
QuickFixTestCase test(singleDocument(original, expected), &factory, QStringList(), 1);
QuickFixTestCase test(singleDocument(original, expected), &factory, ProjectPart::HeaderPaths(),
1);
}
/// Find right implementation file.
@@ -1910,7 +1919,7 @@ void insertToSectionDeclFromDef(const QByteArray &section, int sectionIndex)
testFiles << QuickFixTestDocument::create("file.cpp", original, expected);
InsertDeclFromDef factory;
QuickFixTestCase(testFiles, &factory, QStringList(), sectionIndex);
QuickFixTestCase(testFiles, &factory, ProjectPart::HeaderPaths(), sectionIndex);
}
/// Check from source file: Insert in header file.
@@ -1961,7 +1970,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_normal()
// Do not use the test factory, at least once we want to go through the "full stack".
AddIncludeForUndefinedIdentifier factory;
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Ignore *.moc includes
@@ -1986,7 +1995,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_ignoremoc()
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert include at top for a sorted group
@@ -2012,7 +2021,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_sortingTop(
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert include in the middle for a sorted group
@@ -2038,7 +2047,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_sortingMidd
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert include at bottom for a sorted group
@@ -2064,7 +2073,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_sortingBott
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: For an unsorted group the new include is appended
@@ -2090,7 +2099,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_appendToUns
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert a local include at front if there are only global includes
@@ -2117,7 +2126,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_firstLocalI
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert a global include at back if there are only local includes
@@ -2146,7 +2155,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_firstGlobal
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("<file.h>"));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Prefer group with longest matching prefix
@@ -2176,7 +2185,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_preferGroup
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"prefixc.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Create a new include group if there are only include groups with a different include dir
@@ -2203,7 +2212,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_newGroupIfO
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Include group with mixed include dirs, sorted --> insert properly
@@ -2231,7 +2240,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_mixedDirsSo
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("<firstlib/file.h>"));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Include group with mixed include dirs, unsorted --> append
@@ -2259,7 +2268,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_mixedDirsUn
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("<lastlib/file.h>"));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Include group with mixed include types
@@ -2285,7 +2294,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_mixedInclud
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"z.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Include group with mixed include types
@@ -2311,7 +2320,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_mixedInclud
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"a.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Include group with mixed include types
@@ -2337,7 +2346,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_mixedInclud
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"lib/file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Include group with mixed include types
@@ -2363,7 +2372,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_mixedInclud
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("<lib/file.h>"));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert very first include
@@ -2386,7 +2395,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_noinclude()
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert very first include if there is a c++ style comment on top
@@ -2415,7 +2424,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_veryFirstIn
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: Insert very first include if there is a c style comment on top
@@ -2448,7 +2457,7 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_veryFirstIn
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifierTestFactory factory(QLatin1String("\"file.h\""));
QuickFixTestCase(testFiles, &factory, QStringList(TestIncludePaths::globalIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalIncludePath());
}
/// Check: If a "Qt Class" was not found by the locator, check the header files in the Qt
@@ -2472,8 +2481,8 @@ void CppEditorPlugin::test_quickfix_AddIncludeForUndefinedIdentifier_checkQSomet
+ "/file.cpp", original, expected);
AddIncludeForUndefinedIdentifier factory;
QuickFixTestCase(testFiles,&factory,
QStringList(CppTools::Tests::TestIncludePaths::globalQtCoreIncludePath()));
QuickFixTestCase::run(testFiles, &factory, TestIncludePaths::globalQtCoreIncludePath());
}
/// Check: Move definition from header to cpp.
@@ -2638,7 +2647,7 @@ void CppEditorPlugin::test_quickfix_MoveFuncDefOutside_MemberFuncOutside2()
testFiles << QuickFixTestDocument::create("file.cpp", original, expected);
MoveFuncDefOutside factory;
QuickFixTestCase(testFiles, &factory, QStringList(), 1);
QuickFixTestCase(testFiles, &factory, ProjectPart::HeaderPaths(), 1);
}
/// Check: Move definition from header to cpp (with namespace).
@@ -2951,7 +2960,7 @@ void CppEditorPlugin::test_quickfix_MoveFuncDefOutside_afterClass()
testFiles << QuickFixTestDocument::create("file.cpp", original, expected);
MoveFuncDefOutside factory;
QuickFixTestCase(testFiles, &factory, QStringList(), 1);
QuickFixTestCase(testFiles, &factory, ProjectPart::HeaderPaths(), 1);
}
/// Check if whitespace is respected for operator functions
src/plugins/cppeditor/cppquickfix_test.h
+6 -3
View File
@@ -74,10 +74,13 @@ class QuickFixTestCase : public TestCase
public:
QuickFixTestCase(const QList<QuickFixTestDocument::Ptr> &theTestFiles,
CppQuickFixFactory *factory,
const QStringList &includePaths = QStringList(),
const CppTools::ProjectPart::HeaderPaths &includePaths =
CppTools::ProjectPart::HeaderPaths(),
int resultIndex = 0);
~QuickFixTestCase();
static void run(const QList<QuickFixTestDocument::Ptr> &theTestFiles,
CppQuickFixFactory *factory, const QString &incPath);
private:
QSharedPointer<TextEditor::QuickFixOperation> getFix(CppQuickFixFactory *factory,
CPPEditorWidget *editorWidget,
@@ -89,8 +92,8 @@ private:
CppTools::CppCodeStylePreferences *m_cppCodeStylePreferences;
QByteArray m_cppCodeStylePreferencesOriginalDelegateId;
QStringList m_includePathsToRestore;
bool m_restoreIncludePaths;
CppTools::ProjectPart::HeaderPaths m_headerPathsToRestore;
bool m_restoreHeaderPaths;
};
QList<QuickFixTestDocument::Ptr> singleDocument(const QByteArray &original,
src/plugins/cppeditor/cppquickfixes.cpp
+9 -9
View File
@@ -1896,7 +1896,7 @@ void AddIncludeForUndefinedIdentifier::match(const CppQuickFixInterface &interfa
return;
// find the include paths
QStringList includePaths;
ProjectPart::HeaderPaths headerPaths;
CppModelManagerInterface *modelManager = CppModelManagerInterface::instance();
QList<CppModelManagerInterface::ProjectInfo> projectInfos = modelManager->projectInfos();
bool inProject = false;
@@ -1905,14 +1905,14 @@ void AddIncludeForUndefinedIdentifier::match(const CppQuickFixInterface &interfa
foreach (const ProjectFile &file, part->files) {
if (file.path == doc->fileName()) {
inProject = true;
includePaths += part->includePaths;
headerPaths += part->headerPaths;
}
}
}
}
if (!inProject) {
// better use all include paths than none
includePaths = modelManager->includePaths();
headerPaths = modelManager->headerPaths();
}
// find a include file through the locator
@@ -1933,10 +1933,10 @@ void AddIncludeForUndefinedIdentifier::match(const CppQuickFixInterface &interfa
if (fileInfo.path() == QFileInfo(doc->fileName()).path()) {
shortestInclude = QLatin1Char('"') + fileInfo.fileName() + QLatin1Char('"');
} else {
foreach (const QString &includePath, includePaths) {
if (!fileName.startsWith(includePath))
foreach (const ProjectPart::HeaderPath &headerPath, headerPaths) {
if (!fileName.startsWith(headerPath.path))
continue;
QString relativePath = fileName.mid(includePath.size());
QString relativePath = fileName.mid(headerPath.path.size());
if (!relativePath.isEmpty() && relativePath.at(0) == QLatin1Char('/'))
relativePath = relativePath.mid(1);
if (shortestInclude.isEmpty() || relativePath.size() + 2 < shortestInclude.size())
@@ -1965,11 +1965,11 @@ void AddIncludeForUndefinedIdentifier::match(const CppQuickFixInterface &interfa
// otherwise, check for a header file with the same name in the Qt include paths
} else {
foreach (const QString &includePath, includePaths) {
if (!includePath.contains(QLatin1String("/Qt"))) // "QtCore", "QtGui" etc...
foreach (const ProjectPart::HeaderPath &headerPath, headerPaths) {
if (!headerPath.path.contains(QLatin1String("/Qt"))) // "QtCore", "QtGui" etc...
continue;
const QString headerPathCandidate = includePath + QLatin1Char('/') + className;
const QString headerPathCandidate = headerPath.path + QLatin1Char('/') + className;
const QFileInfo fileInfo(headerPathCandidate);
if (fileInfo.exists() && fileInfo.isFile()) {
const QString include = QLatin1Char('<') + className + QLatin1Char('>');
src/plugins/cpptools/builtinindexingsupport.cpp
+6 -7
View File
@@ -51,7 +51,7 @@ static void parse(QFutureInterface<void> &future,
bool processingHeaders = false;
CppModelManager *cmm = CppModelManager::instance();
const QStringList fallbackIncludePaths = cmm->includePaths();
const ProjectPart::HeaderPaths fallbackHeaderPaths = cmm->headerPaths();
for (int i = 0; i < files.size(); ++i) {
if (future.isPaused())
future.waitForResume();
@@ -71,10 +71,10 @@ static void parse(QFutureInterface<void> &future,
}
QList<ProjectPart::Ptr> parts = cmm->projectPart(fileName);
QStringList includePaths = parts.isEmpty()
? fallbackIncludePaths
: parts.first()->includePaths;
sourceProcessor->setIncludePaths(includePaths);
ProjectPart::HeaderPaths headerPaths = parts.isEmpty()
? fallbackHeaderPaths
: parts.first()->headerPaths;
sourceProcessor->setHeaderPaths(headerPaths);
sourceProcessor->run(fileName);
future.setProgressValue(files.size() - sourceProcessor->todo().size());
@@ -190,8 +190,7 @@ QFuture<void> BuiltinIndexingSupport::refreshSourceFiles(const QStringList &sour
CppSourceProcessor *preproc = CppModelManager::createSourceProcessor();
preproc->setDumpFileNameWhileParsing(m_dumpFileNameWhileParsing);
preproc->setRevision(++m_revision);
preproc->setIncludePaths(mgr->includePaths());
preproc->setFrameworkPaths(mgr->frameworkPaths());
preproc->setHeaderPaths(mgr->headerPaths());
preproc->setWorkingCopy(workingCopy);
QFuture<void> result = QtConcurrent::run(&parse, preproc, sourceFiles);
src/plugins/cpptools/cppcodemodelinspectordumper.cpp
+26 -16
View File
@@ -413,6 +413,18 @@ QString Utils::pathListToString(const QStringList &pathList)
return result.join(QLatin1String("\n"));
}
QString Utils::pathListToString(const ProjectPart::HeaderPaths &pathList)
{
QStringList result;
foreach (const ProjectPart::HeaderPath &path, pathList) {
result << QString(QLatin1String("%1 (%2 path)")).arg(
QDir::toNativeSeparators(path.path),
path.isFrameworkPath() ? QLatin1String("framework") : QLatin1String("include")
);
}
return result.join(QLatin1String("\n"));
}
QList<CPlusPlus::Document::Ptr> Utils::snapshotToList(const CPlusPlus::Snapshot &snapshot)
{
QList<CPlusPlus::Document::Ptr> documents;
@@ -511,16 +523,14 @@ void Dumper::dumpProjectInfos( const QList<CppModelManagerInterface::ProjectInfo
m_out << i4 << defineLine << "\n";
}
if (!part->includePaths.isEmpty()) {
m_out << i3 << "Include Paths:{{{4\n";
foreach (const QString &includePath, part->includePaths)
m_out << i4 << includePath << "\n";
}
if (!part->frameworkPaths.isEmpty()) {
m_out << i3 << "Framework Paths:{{{4\n";
foreach (const QString &frameworkPath, part->frameworkPaths)
m_out << i4 << frameworkPath << "\n";
if (!part->headerPaths.isEmpty()) {
m_out << i3 << "Header Paths:{{{4\n";
foreach (const ProjectPart::HeaderPath &headerPath, part->headerPaths)
m_out << i4 << headerPath.path
<< (headerPath.type == ProjectPart::HeaderPath::IncludePath
? "(include path)"
: "(framework path)")
<< "\n";
}
if (!part->precompiledHeaders.isEmpty()) {
@@ -582,18 +592,18 @@ void Dumper::dumpWorkingCopy(const CppModelManagerInterface::WorkingCopy &workin
}
}
void Dumper::dumpMergedEntities(const QStringList &mergedIncludePaths,
const QStringList &mergedFrameworkPaths,
void Dumper::dumpMergedEntities(const ProjectPart::HeaderPaths &mergedHeaderPaths,
const QByteArray &mergedMacros)
{
m_out << "Merged Entities{{{1\n";
const QByteArray i2 = indent(2);
const QByteArray i3 = indent(3);
m_out << i2 << "Merged Include Paths{{{2\n";
dumpStringList(mergedIncludePaths, i3);
m_out << i2 << "Merged Framework Paths{{{2\n";
dumpStringList(mergedFrameworkPaths, i3);
m_out << i2 << "Merged Header Paths{{{2\n";
foreach (const ProjectPart::HeaderPath &hp, mergedHeaderPaths)
m_out << i3 << hp.path
<< (hp.isFrameworkPath() ? " (framework path)" : " (include path)")
<< "\n";
m_out << i2 << "Merged Defines{{{2\n";
m_out << mergedMacros;
}
src/plugins/cpptools/cppcodemodelinspectordumper.h
+2 -2
View File
@@ -58,6 +58,7 @@ struct CPPTOOLS_EXPORT Utils
static QString partsForFile(const QString &fileName);
static QString unresolvedFileNameWithDelimiters(const CPlusPlus::Document::Include &include);
static QString pathListToString(const QStringList &pathList);
static QString pathListToString(const ProjectPart::HeaderPaths &pathList);
static QList<CPlusPlus::Document::Ptr> snapshotToList(const CPlusPlus::Snapshot &snapshot);
};
@@ -73,8 +74,7 @@ public:
const QString &title,
bool isGlobalSnapshot = false);
void dumpWorkingCopy(const CppTools::CppModelManagerInterface::WorkingCopy &workingCopy);
void dumpMergedEntities(const QStringList &mergedIncludePaths,
const QStringList &mergedFrameworkPaths,
void dumpMergedEntities(const ProjectPart::HeaderPaths &mergedHeaderPaths,
const QByteArray &mergedMacros);
private:
src/plugins/cpptools/cppcompletion_test.cpp
+1 -1
View File
@@ -105,7 +105,7 @@ public:
= new CppCompletionAssistInterface(m_editorWidget->document(), m_position,
m_editorWidget->baseTextDocument()->filePath(),
ExplicitlyInvoked, m_snapshot,
QStringList(), QStringList());
ProjectPart::HeaderPaths());
CppCompletionAssistProcessor processor;
IAssistProposal *proposal = processor.perform(ai);
if (!proposal)
src/plugins/cpptools/cppcompletionassist.cpp
+10 -18
View File
@@ -1139,30 +1139,23 @@ bool CppCompletionAssistProcessor::completeInclude(const QTextCursor &cursor)
}
// Make completion for all relevant includes
QStringList includePaths = m_interface->includePaths();
const QString &currentFilePath = QFileInfo(m_interface->fileName()).path();
if (!includePaths.contains(currentFilePath))
includePaths.append(currentFilePath);
ProjectPart::HeaderPaths headerPaths = m_interface->headerPaths();
const ProjectPart::HeaderPath currentFilePath(QFileInfo(m_interface->fileName()).path(),
ProjectPart::HeaderPath::IncludePath);
if (!headerPaths.contains(currentFilePath))
headerPaths.append(currentFilePath);
const Core::MimeType mimeType =
Core::MimeDatabase::findByType(QLatin1String("text/x-c++hdr"));
const QStringList suffixes = mimeType.suffixes();
foreach (const QString &includePath, includePaths) {
QString realPath = includePath;
foreach (const ProjectPart::HeaderPath &headerPath, headerPaths) {
QString realPath = headerPath.path;
if (!directoryPrefix.isEmpty()) {
realPath += QLatin1Char('/');
realPath += directoryPrefix;
}
completeInclude(realPath, suffixes);
}
foreach (const QString &frameworkPath, m_interface->frameworkPaths()) {
QString realPath = frameworkPath;
if (!directoryPrefix.isEmpty()) {
realPath += QLatin1Char('/');
realPath += directoryPrefix;
realPath += QLatin1String(".framework/Headers");
if (headerPath.isFrameworkPath())
realPath += QLatin1String(".framework/Headers");
}
completeInclude(realPath, suffixes);
}
@@ -1969,8 +1962,7 @@ void CppCompletionAssistInterface::getCppSpecifics() const
if (QSharedPointer<SnapshotUpdater> updater = supp->snapshotUpdater()) {
updater->update(m_workingCopy);
m_snapshot = updater->snapshot();
m_includePaths = updater->includePaths();
m_frameworkPaths = updater->frameworkPaths();
m_headerPaths = updater->headerPaths();
}
}
}
src/plugins/cpptools/cppcompletionassist.h
+5 -8
View File
@@ -191,22 +191,20 @@ public:
const QString &fileName,
TextEditor::AssistReason reason,
const CPlusPlus::Snapshot &snapshot,
const QStringList &includePaths,
const QStringList &frameworkPaths)
const ProjectPart::HeaderPaths &headerPaths)
: TextEditor::DefaultAssistInterface(textDocument, position, fileName, reason)
, m_editor(0)
, m_isObjCEnabled(false)
, m_gotCppSpecifics(true)
, m_snapshot(snapshot)
, m_includePaths(includePaths)
, m_frameworkPaths(frameworkPaths)
, m_headerPaths(headerPaths)
{}
bool isObjCEnabled() const { return m_isObjCEnabled; }
const CPlusPlus::Snapshot &snapshot() const { getCppSpecifics(); return m_snapshot; }
const QStringList &includePaths() const { getCppSpecifics(); return m_includePaths; }
const QStringList &frameworkPaths() const { getCppSpecifics(); return m_frameworkPaths; }
const ProjectPart::HeaderPaths &headerPaths() const
{ getCppSpecifics(); return m_headerPaths; }
private:
void getCppSpecifics() const;
@@ -216,8 +214,7 @@ private:
mutable bool m_gotCppSpecifics;
CppModelManagerInterface::WorkingCopy m_workingCopy;
mutable CPlusPlus::Snapshot m_snapshot;
mutable QStringList m_includePaths;
mutable QStringList m_frameworkPaths;
mutable ProjectPart::HeaderPaths m_headerPaths;
};
} // Internal
src/plugins/cpptools/cppmodelmanager.cpp
+15 -29
View File
@@ -298,8 +298,7 @@ void CppModelManager::ensureUpdated()
return;
m_projectFiles = internalProjectFiles();
m_includePaths = internalIncludePaths();
m_frameworkPaths = internalFrameworkPaths();
m_headerPaths = internalHeaderPaths();
m_definedMacros = internalDefinedMacros();
m_dirty = false;
}
@@ -320,34 +319,23 @@ QStringList CppModelManager::internalProjectFiles() const
return files;
}
QStringList CppModelManager::internalIncludePaths() const
ProjectPart::HeaderPaths CppModelManager::internalHeaderPaths() const
{
QStringList includePaths;
ProjectPart::HeaderPaths headerPaths;
QMapIterator<ProjectExplorer::Project *, ProjectInfo> it(m_projectToProjectsInfo);
while (it.hasNext()) {
it.next();
const ProjectInfo pinfo = it.value();
foreach (const ProjectPart::Ptr &part, pinfo.projectParts())
foreach (const QString &path, part->includePaths)
includePaths.append(CppSourceProcessor::cleanPath(path));
foreach (const ProjectPart::Ptr &part, pinfo.projectParts()) {
foreach (const ProjectPart::HeaderPath &path, part->headerPaths) {
const ProjectPart::HeaderPath hp(CppSourceProcessor::cleanPath(path.path),
path.type);
if (!headerPaths.contains(hp))
headerPaths += hp;
}
}
}
includePaths.removeDuplicates();
return includePaths;
}
QStringList CppModelManager::internalFrameworkPaths() const
{
QStringList frameworkPaths;
QMapIterator<ProjectExplorer::Project *, ProjectInfo> it(m_projectToProjectsInfo);
while (it.hasNext()) {
it.next();
const ProjectInfo pinfo = it.value();
foreach (const ProjectPart::Ptr &part, pinfo.projectParts())
foreach (const QString &path, part->frameworkPaths)
frameworkPaths.append(CppSourceProcessor::cleanPath(path));
}
frameworkPaths.removeDuplicates();
return frameworkPaths;
return headerPaths;
}
static void addUnique(const QList<QByteArray> &defs, QByteArray *macros, QSet<QByteArray> *alreadyIn)
@@ -396,7 +384,7 @@ void CppModelManager::dumpModelManagerConfiguration(const QString &logFileId)
dumper.dumpSnapshot(globalSnapshot, globalSnapshotTitle, /*isGlobalSnapshot=*/ true);
dumper.dumpWorkingCopy(workingCopy());
ensureUpdated();
dumper.dumpMergedEntities(m_includePaths, m_frameworkPaths, m_definedMacros);
dumper.dumpMergedEntities(m_headerPaths, m_definedMacros);
}
void CppModelManager::addExtraEditorSupport(AbstractEditorSupport *editorSupport)
@@ -595,8 +583,7 @@ public:
bool configurationChanged() const
{
return definesChanged()
|| m_new.includePaths() != m_old.includePaths()
|| m_new.frameworkPaths() != m_old.frameworkPaths();
|| m_new.headerPaths() != m_old.headerPaths();
}
bool nothingChanged() const
@@ -761,8 +748,7 @@ ProjectPart::Ptr CppModelManager::fallbackProjectPart() const
ProjectPart::Ptr part(new ProjectPart);
part->projectDefines = m_definedMacros;
part->includePaths = m_includePaths;
part->frameworkPaths = m_frameworkPaths;
part->headerPaths = m_headerPaths;
part->cVersion = ProjectPart::C11;
part->cxxVersion = ProjectPart::CXX11;
part->cxxExtensions = ProjectPart::AllExtensions;
src/plugins/cpptools/cppmodelmanager.h
+6 -14
View File
@@ -128,22 +128,16 @@ public:
return m_projectFiles;
}
QStringList includePaths()
ProjectPart::HeaderPaths headerPaths()
{
ensureUpdated();
return m_includePaths;
return m_headerPaths;
}
// Use this *only* for auto tests
void setIncludePaths(const QStringList &includePaths)
void setHeaderPaths(const ProjectPart::HeaderPaths &headerPaths)
{
m_includePaths = includePaths;
}
QStringList frameworkPaths()
{
ensureUpdated();
return m_frameworkPaths;
m_headerPaths = headerPaths;
}
QByteArray definedMacros()
@@ -187,8 +181,7 @@ private:
void ensureUpdated();
QStringList internalProjectFiles() const;
QStringList internalIncludePaths() const;
QStringList internalFrameworkPaths() const;
ProjectPart::HeaderPaths internalHeaderPaths() const;
QByteArray internalDefinedMacros() const;
void dumpModelManagerConfiguration(const QString &logFileId);
@@ -210,8 +203,7 @@ private:
// The members below are cached/(re)calculated from the projects and/or their project parts
bool m_dirty;
QStringList m_projectFiles;
QStringList m_includePaths;
QStringList m_frameworkPaths;
ProjectPart::HeaderPaths m_headerPaths;
QByteArray m_definedMacros;
// Editor integration
src/plugins/cpptools/cppmodelmanager_test.cpp
+37 -18
View File
@@ -220,23 +220,24 @@ void CppToolsPlugin::test_modelmanager_paths_are_clean()
ProjectInfo pi = mm->projectInfo(project);
QCOMPARE(pi.project().data(), project);
typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98;
part->qtVersion = ProjectPart::Qt5;
part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
part->includePaths = QStringList() << testDataDir.includeDir(false);
part->frameworkPaths = QStringList() << testDataDir.frameworksDir(false);
part->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDir.includeDir(false), HeaderPath::IncludePath)
<< HeaderPath(testDataDir.frameworksDir(false), HeaderPath::FrameworkPath);
pi.appendProjectPart(part);
mm->updateProjectInfo(pi);
QStringList includePaths = mm->includePaths();
QCOMPARE(includePaths.size(), 1);
QVERIFY(includePaths.contains(testDataDir.includeDir()));
QStringList frameworkPaths = mm->frameworkPaths();
QCOMPARE(frameworkPaths.size(), 1);
QVERIFY(frameworkPaths.contains(testDataDir.frameworksDir()));
QList<HeaderPath> headerPaths = mm->headerPaths();
QCOMPARE(headerPaths.size(), 2);
QVERIFY(headerPaths.contains(HeaderPath(testDataDir.includeDir(), HeaderPath::IncludePath)));
QVERIFY(headerPaths.contains(HeaderPath(testDataDir.frameworksDir(),
HeaderPath::FrameworkPath)));
}
/// Check: Frameworks headers are resolved.
@@ -254,12 +255,15 @@ void CppToolsPlugin::test_modelmanager_framework_headers()
ProjectInfo pi = mm->projectInfo(project);
QCOMPARE(pi.project().data(), project);
typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98;
part->qtVersion = ProjectPart::Qt5;
part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
part->includePaths << testDataDir.includeDir();
part->frameworkPaths << testDataDir.frameworksDir();
part->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDir.includeDir(false), HeaderPath::IncludePath)
<< HeaderPath(testDataDir.frameworksDir(false), HeaderPath::FrameworkPath);
const QString &source = testDataDir.fileFromSourcesDir(
_("test_modelmanager_framework_headers.cpp"));
part->files << ProjectFile(source, ProjectFile::CXXSource);
@@ -303,11 +307,14 @@ void CppToolsPlugin::test_modelmanager_refresh_also_includes_of_project_files()
ProjectInfo pi = mm->projectInfo(project);
QCOMPARE(pi.project().data(), project);
typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part(new ProjectPart);
part->cxxVersion = ProjectPart::CXX98;
part->qtVersion = ProjectPart::Qt5;
part->projectDefines = QByteArray("#define OH_BEHAVE -1\n");
part->includePaths = QStringList() << testDataDir.includeDir(false);
part->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDir.includeDir(false), HeaderPath::IncludePath);
part->files.append(ProjectFile(testCpp, ProjectFile::CXXSource));
pi.appendProjectPart(part);
@@ -806,6 +813,8 @@ void CppToolsPlugin::test_modelmanager_defines_per_project()
Project *project = helper.createProject(_("test_modelmanager_defines_per_project"));
typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part1(new ProjectPart);
part1->projectFile = QLatin1String("project1.projectfile");
part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
@@ -813,7 +822,8 @@ void CppToolsPlugin::test_modelmanager_defines_per_project()
part1->cxxVersion = ProjectPart::CXX11;
part1->qtVersion = ProjectPart::NoQt;
part1->projectDefines = QByteArray("#define SUB1\n");
part1->includePaths = QStringList() << testDataDirectory.includeDir(false);
part1->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
ProjectPart::Ptr part2(new ProjectPart);
part2->projectFile = QLatin1String("project1.projectfile");
@@ -822,7 +832,8 @@ void CppToolsPlugin::test_modelmanager_defines_per_project()
part2->cxxVersion = ProjectPart::CXX11;
part2->qtVersion = ProjectPart::NoQt;
part2->projectDefines = QByteArray("#define SUB2\n");
part2->includePaths = QStringList() << testDataDirectory.includeDir(false);
part2->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
ProjectInfo pi = mm->projectInfo(project);
pi.appendProjectPart(part1);
@@ -877,6 +888,8 @@ void CppToolsPlugin::test_modelmanager_defines_per_project_pch()
Project *project = helper.createProject(_("test_modelmanager_defines_per_project_pch"));
typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part1(new ProjectPart);
part1->projectFile = QLatin1String("project1.projectfile");
part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
@@ -884,7 +897,8 @@ void CppToolsPlugin::test_modelmanager_defines_per_project_pch()
part1->cxxVersion = ProjectPart::CXX11;
part1->qtVersion = ProjectPart::NoQt;
part1->precompiledHeaders.append(pch1File);
part1->includePaths = QStringList() << testDataDirectory.includeDir(false);
part1->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
ProjectPart::Ptr part2(new ProjectPart);
part2->projectFile = QLatin1String("project2.projectfile");
@@ -893,7 +907,8 @@ void CppToolsPlugin::test_modelmanager_defines_per_project_pch()
part2->cxxVersion = ProjectPart::CXX11;
part2->qtVersion = ProjectPart::NoQt;
part2->precompiledHeaders.append(pch2File);
part2->includePaths = QStringList() << testDataDirectory.includeDir(false);
part2->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
ProjectInfo pi = mm->projectInfo(project);
pi.appendProjectPart(part1);
@@ -949,19 +964,23 @@ void CppToolsPlugin::test_modelmanager_defines_per_editor()
Project *project = helper.createProject(_("test_modelmanager_defines_per_editor"));
typedef ProjectPart::HeaderPath HeaderPath;
ProjectPart::Ptr part1(new ProjectPart);
part1->files.append(ProjectFile(main1File, ProjectFile::CXXSource));
part1->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part1->cxxVersion = ProjectPart::CXX11;
part1->qtVersion = ProjectPart::NoQt;
part1->includePaths = QStringList() << testDataDirectory.includeDir(false);
part1->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
ProjectPart::Ptr part2(new ProjectPart);
part2->files.append(ProjectFile(main2File, ProjectFile::CXXSource));
part2->files.append(ProjectFile(header, ProjectFile::CXXHeader));
part2->cxxVersion = ProjectPart::CXX11;
part2->qtVersion = ProjectPart::NoQt;
part2->includePaths = QStringList() << testDataDirectory.includeDir(false);
part2->headerPaths = QList<HeaderPath>()
<< HeaderPath(testDataDirectory.includeDir(false), HeaderPath::IncludePath);
ProjectInfo pi = mm->projectInfo(project);
pi.appendProjectPart(part1);
src/plugins/cpptools/cppmodelmanagerinterface.cpp
+16 -18
View File
@@ -154,12 +154,12 @@ void ProjectPart::evaluateToolchain(const ToolChain *tc,
cWarningFlags = tc->warningFlags(cflags);
cxxWarningFlags = tc->warningFlags(cxxflags);
const QList<HeaderPath> headers = tc->systemHeaderPaths(cxxflags, sysRoot);
foreach (const HeaderPath &header, headers)
if (header.kind() == HeaderPath::FrameworkHeaderPath)
frameworkPaths << header.path();
else
includePaths << header.path();
const QList<ProjectExplorer::HeaderPath> headers = tc->systemHeaderPaths(cxxflags, sysRoot);
foreach (const ProjectExplorer::HeaderPath &header, headers) {
headerPaths << HeaderPath(header.path(),
header.kind() == ProjectExplorer::HeaderPath::FrameworkHeaderPath
? HeaderPath::FrameworkPath : HeaderPath::IncludePath);
}
toolchainDefines = tc->predefinedMacros(cxxflags);
}
@@ -187,8 +187,7 @@ CppModelManagerInterface *CppModelManagerInterface::instance()
void CppModelManagerInterface::ProjectInfo::clearProjectParts()
{
m_projectParts.clear();
m_includePaths.clear();
m_frameworkPaths.clear();
m_headerPaths.clear();
m_sourceFiles.clear();
m_defines.clear();
}
@@ -200,17 +199,16 @@ void CppModelManagerInterface::ProjectInfo::appendProjectPart(const ProjectPart:
m_projectParts.append(part);
// Update include paths
QSet<QString> incs = QSet<QString>::fromList(m_includePaths);
foreach (const QString &ins, part->includePaths)
incs.insert(ins);
m_includePaths = incs.toList();
typedef ProjectPart::HeaderPath HeaderPath;
// Update framework paths
QSet<QString> frms = QSet<QString>::fromList(m_frameworkPaths);
foreach (const QString &frm, part->frameworkPaths)
frms.insert(frm);
m_frameworkPaths = frms.toList();
// Update header paths
QSet<HeaderPath> incs = QSet<HeaderPath>::fromList(m_headerPaths);
foreach (const HeaderPath &hp, part->headerPaths) {
if (!incs.contains(hp)) {
incs.insert(hp);
m_headerPaths += hp;
}
}
// Update source files
QSet<QString> srcs = QSet<QString>::fromList(m_sourceFiles);
src/plugins/cpptools/cppmodelmanagerinterface.h
+30 -12
View File
@@ -101,6 +101,27 @@ public:
typedef QSharedPointer<ProjectPart> Ptr;
struct HeaderPath {
enum Type { InvalidPath, IncludePath, FrameworkPath };
public:
QString path;
Type type;
HeaderPath(): type(InvalidPath) {}
HeaderPath(const QString &path, Type type): path(path), type(type) {}
bool isValid() const { return type != InvalidPath; }
bool isFrameworkPath() const { return type == FrameworkPath; }
bool operator==(const HeaderPath &other) const
{ return path == other.path && type == other.type; }
bool operator!=(const HeaderPath &other) const
{ return !(*this == other); }
};
typedef QList<HeaderPath> HeaderPaths;
public:
QString displayName;
QString projectFile;
@@ -109,8 +130,7 @@ public:
QString projectConfigFile; // currently only used by the Generic Project Manager
QByteArray projectDefines;
QByteArray toolchainDefines;
QStringList includePaths;
QStringList frameworkPaths;
QList<HeaderPath> headerPaths;
QStringList precompiledHeaders;
CVersion cVersion;
CXXVersion cxxVersion;
@@ -120,6 +140,9 @@ public:
ProjectExplorer::ToolChain::WarningFlags cxxWarningFlags;
};
inline uint qHash(const ProjectPart::HeaderPath &key, uint seed = 0)
{ return ((qHash(key.path) << 2) | key.type) ^ seed; }
class CPPTOOLS_EXPORT CppModelManagerInterface : public CPlusPlus::CppModelManagerBase
{
Q_OBJECT
@@ -159,11 +182,8 @@ public:
void clearProjectParts();
void appendProjectPart(const ProjectPart::Ptr &part);
const QStringList includePaths() const
{ return m_includePaths; }
const QStringList frameworkPaths() const
{ return m_frameworkPaths; }
const ProjectPart::HeaderPaths headerPaths() const
{ return m_headerPaths; }
const QStringList sourceFiles() const
{ return m_sourceFiles; }
@@ -175,8 +195,7 @@ public:
QPointer<ProjectExplorer::Project> m_project;
QList<ProjectPart::Ptr> m_projectParts;
// The members below are (re)calculated from the project parts once a part is appended.
QStringList m_includePaths;
QStringList m_frameworkPaths;
ProjectPart::HeaderPaths m_headerPaths;
QStringList m_sourceFiles;
QByteArray m_defines;
};
@@ -266,11 +285,10 @@ public:
virtual void setIndexingSupport(CppTools::CppIndexingSupport *indexingSupport) = 0;
virtual CppIndexingSupport *indexingSupport() = 0;
virtual void setIncludePaths(const QStringList &includePaths) = 0;
virtual void setHeaderPaths(const ProjectPart::HeaderPaths &headerPaths) = 0;
virtual void enableGarbageCollector(bool enable) = 0;
virtual QStringList includePaths() = 0;
virtual QStringList frameworkPaths() = 0;
virtual ProjectPart::HeaderPaths headerPaths() = 0;
virtual QByteArray definedMacros() = 0;
signals:
src/plugins/cpptools/cppsnapshotupdater.cpp
+7 -21
View File
@@ -57,8 +57,7 @@ void SnapshotUpdater::update(CppModelManager::WorkingCopy workingCopy)
CppModelManager *modelManager
= dynamic_cast<CppModelManager *>(CppModelManagerInterface::instance());
QByteArray configFile = modelManager->codeModelConfiguration();
QStringList includePaths;
QStringList frameworkPaths;
ProjectPart::HeaderPaths headerPaths;
QStringList precompiledHeaders;
QString projectConfigFile;
@@ -72,8 +71,7 @@ void SnapshotUpdater::update(CppModelManager::WorkingCopy workingCopy)
if (m_projectPart) {
configFile += m_projectPart->toolchainDefines;
configFile += m_projectPart->projectDefines;
includePaths = m_projectPart->includePaths;
frameworkPaths = m_projectPart->frameworkPaths;
headerPaths = m_projectPart->headerPaths;
projectConfigFile = m_projectPart->projectConfigFile;
if (m_usePrecompiledHeaders)
precompiledHeaders = m_projectPart->precompiledHeaders;
@@ -91,13 +89,8 @@ void SnapshotUpdater::update(CppModelManager::WorkingCopy workingCopy)
m_editorDefinesChangedSinceLastUpdate = false;
}
if (includePaths != m_includePaths) {
m_includePaths = includePaths;
invalidateSnapshot = true;
}
if (frameworkPaths != m_frameworkPaths) {
m_frameworkPaths = frameworkPaths;
if (headerPaths != m_headerPaths) {
m_headerPaths = headerPaths;
invalidateSnapshot = true;
}
@@ -174,8 +167,7 @@ void SnapshotUpdater::update(CppModelManager::WorkingCopy workingCopy)
globalSnapshot.remove(fileInEditor());
sourceProcessor.setGlobalSnapshot(globalSnapshot);
sourceProcessor.setWorkingCopy(workingCopy);
sourceProcessor.setIncludePaths(m_includePaths);
sourceProcessor.setFrameworkPaths(m_frameworkPaths);
sourceProcessor.setHeaderPaths(m_headerPaths);
sourceProcessor.run(configurationFileName);
if (!m_projectConfigFile.isEmpty())
sourceProcessor.run(m_projectConfigFile);
@@ -218,16 +210,10 @@ Snapshot SnapshotUpdater::snapshot() const
return m_snapshot;
}
QStringList SnapshotUpdater::includePaths() const
ProjectPart::HeaderPaths SnapshotUpdater::headerPaths() const
{
QMutexLocker locker(&m_mutex);
return m_includePaths;
}
QStringList SnapshotUpdater::frameworkPaths() const
{
QMutexLocker locker(&m_mutex);
return m_frameworkPaths;
return m_headerPaths;
}
ProjectPart::Ptr SnapshotUpdater::currentProjectPart() const
src/plugins/cpptools/cppsnapshotupdater.h
+2 -4
View File
@@ -56,8 +56,7 @@ public:
CPlusPlus::Document::Ptr document() const;
CPlusPlus::Snapshot snapshot() const;
QStringList includePaths() const;
QStringList frameworkPaths() const;
ProjectPart::HeaderPaths headerPaths() const;
ProjectPart::Ptr currentProjectPart() const;
void setProjectPart(ProjectPart::Ptr projectPart);
@@ -76,8 +75,7 @@ private:
QByteArray m_configFile;
bool m_editorDefinesChangedSinceLastUpdate;
QByteArray m_editorDefines;
QStringList m_includePaths;
QStringList m_frameworkPaths;
ProjectPart::HeaderPaths m_headerPaths;
QString m_projectConfigFile;
QStringList m_precompiledHeaders;
CPlusPlus::Snapshot m_snapshot;
src/plugins/cpptools/cppsourceprocessor.cpp
+27 -36
View File
@@ -6,6 +6,7 @@
#include <utils/fileutils.h>
#include <utils/hostosinfo.h>
#include <utils/qtcassert.h>
#include <utils/textfileformat.h>
#include <QCoreApplication>
@@ -98,38 +99,20 @@ void CppSourceProcessor::setRevision(unsigned revision)
void CppSourceProcessor::setWorkingCopy(const CppModelManagerInterface::WorkingCopy &workingCopy)
{ m_workingCopy = workingCopy; }
void CppSourceProcessor::setIncludePaths(const QStringList &includePaths)
void CppSourceProcessor::setHeaderPaths(const ProjectPart::HeaderPaths &headerPaths)
{
m_includePaths.clear();
m_headerPaths.clear();
for (int i = 0; i < includePaths.size(); ++i) {
const QString &path = includePaths.at(i);
for (int i = 0, ei = headerPaths.size(); i < ei; ++i) {
const ProjectPart::HeaderPath &path = headerPaths.at(i);
if (Utils::HostOsInfo::isMacHost()) {
if (i + 1 < includePaths.size() && path.endsWith(QLatin1String(".framework/Headers"))) {
const QFileInfo pathInfo(path);
const QFileInfo frameworkFileInfo(pathInfo.path());
const QString frameworkName = frameworkFileInfo.baseName();
const QFileInfo nextIncludePath = includePaths.at(i + 1);
if (nextIncludePath.fileName() == frameworkName) {
// We got a QtXXX.framework/Headers followed by $QTDIR/include/QtXXX.
// In this case we prefer to include files from $QTDIR/include/QtXXX.
continue;
}
}
}
m_includePaths.append(cleanPath(path));
if (path.type == ProjectPart::HeaderPath::IncludePath)
m_headerPaths.append(ProjectPart::HeaderPath(cleanPath(path.path), path.type));
else
addFrameworkPath(path);
}
}
void CppSourceProcessor::setFrameworkPaths(const QStringList &frameworkPaths)
{
m_frameworkPaths.clear();
foreach (const QString &frameworkPath, frameworkPaths)
addFrameworkPath(frameworkPath);
}
// Add the given framework path, and expand private frameworks.
//
// Example:
@@ -137,16 +120,19 @@ void CppSourceProcessor::setFrameworkPaths(const QStringList &frameworkPaths)
// has private frameworks in:
// <framework-path>/ApplicationServices.framework/Frameworks
// if the "Frameworks" folder exists inside the top level framework.
void CppSourceProcessor::addFrameworkPath(const QString &frameworkPath)
void CppSourceProcessor::addFrameworkPath(const ProjectPart::HeaderPath &frameworkPath)
{
QTC_ASSERT(frameworkPath.isFrameworkPath(), return);
// The algorithm below is a bit too eager, but that's because we're not getting
// in the frameworks we're linking against. If we would have that, then we could
// add only those private frameworks.
const QString cleanFrameworkPath = cleanPath(frameworkPath);
if (!m_frameworkPaths.contains(cleanFrameworkPath))
m_frameworkPaths.append(cleanFrameworkPath);
const ProjectPart::HeaderPath cleanFrameworkPath(cleanPath(frameworkPath.path),
frameworkPath.type);
if (!m_headerPaths.contains(cleanFrameworkPath))
m_headerPaths.append(cleanFrameworkPath);
const QDir frameworkDir(cleanFrameworkPath);
const QDir frameworkDir(cleanFrameworkPath.path);
const QStringList filter = QStringList() << QLatin1String("*.framework");
foreach (const QFileInfo &framework, frameworkDir.entryInfoList(filter)) {
if (!framework.isDir())
@@ -154,7 +140,8 @@ void CppSourceProcessor::addFrameworkPath(const QString &frameworkPath)
const QFileInfo privateFrameworks(framework.absoluteFilePath(),
QLatin1String("Frameworks"));
if (privateFrameworks.exists() && privateFrameworks.isDir())
addFrameworkPath(privateFrameworks.absoluteFilePath());
addFrameworkPath(ProjectPart::HeaderPath(privateFrameworks.absoluteFilePath(),
frameworkPath.type));
}
}
@@ -259,8 +246,10 @@ QString CppSourceProcessor::resolveFile_helper(const QString &fileName, IncludeT
// searching as if this would be a global include.
}
foreach (const QString &includePath, m_includePaths) {
const QString path = includePath + fileName;
foreach (const ProjectPart::HeaderPath &headerPath, m_headerPaths) {
if (headerPath.isFrameworkPath())
continue;
const QString path = headerPath.path + fileName;
if (m_workingCopy.contains(path) || checkFile(path))
return path;
}
@@ -271,8 +260,10 @@ QString CppSourceProcessor::resolveFile_helper(const QString &fileName, IncludeT
const QString name = frameworkName + QLatin1String(".framework/Headers/")
+ fileName.mid(index + 1);
foreach (const QString &frameworkPath, m_frameworkPaths) {
const QString path = frameworkPath + name;
foreach (const ProjectPart::HeaderPath &headerPath, m_headerPaths) {
if (!headerPath.isFrameworkPath())
continue;
const QString path = headerPath.path + name;
if (checkFile(path))
return path;
}
src/plugins/cpptools/cppsourceprocessor.h
+3 -5
View File
@@ -40,8 +40,7 @@ public:
void setRevision(unsigned revision);
void setWorkingCopy(const CppTools::CppModelManagerInterface::WorkingCopy &workingCopy);
void setIncludePaths(const QStringList &includePaths);
void setFrameworkPaths(const QStringList &frameworkPaths);
void setHeaderPaths(const ProjectPart::HeaderPaths &headerPaths);
void setTodo(const QStringList &files);
void run(const QString &fileName);
@@ -54,7 +53,7 @@ public:
void setGlobalSnapshot(const CPlusPlus::Snapshot &snapshot) { m_globalSnapshot = snapshot; }
private:
void addFrameworkPath(const QString &frameworkPath);
void addFrameworkPath(const ProjectPart::HeaderPath &frameworkPath);
CPlusPlus::Document::Ptr switchCurrentDocument(CPlusPlus::Document::Ptr doc);
@@ -90,9 +89,8 @@ private:
bool m_dumpFileNameWhileParsing;
CPlusPlus::Environment m_env;
CPlusPlus::Preprocessor m_preprocess;
QStringList m_includePaths;
ProjectPart::HeaderPaths m_headerPaths;
CppTools::CppModelManagerInterface::WorkingCopy m_workingCopy;
QStringList m_frameworkPaths;
QSet<QString> m_included;
CPlusPlus::Document::Ptr m_currentDoc;
QSet<QString> m_todo;
src/plugins/cpptools/cppsourceprocessor_test.cpp
+3 -1
View File
@@ -71,7 +71,9 @@ public:
QScopedPointer<CppSourceProcessor> sourceProcessor(
CppModelManager::createSourceProcessor());
sourceProcessor->setIncludePaths(QStringList(TestIncludePaths::directoryOfTestFile()));
const ProjectPart::HeaderPath hp(TestIncludePaths::directoryOfTestFile(),
ProjectPart::HeaderPath::IncludePath);
sourceProcessor->setHeaderPaths(ProjectPart::HeaderPaths() << hp);
sourceProcessor->run(fileName);
Document::Ptr document = m_cmm->document(fileName);
src/plugins/cpptools/includeutils.cpp
+4 -1
View File
@@ -518,7 +518,10 @@ static QList<Include> includesForSource(const QByteArray &source)
CppModelManager *cmm = CppModelManager::instance();
cmm->GC();
QScopedPointer<CppSourceProcessor> sourceProcessor(CppModelManager::createSourceProcessor());
sourceProcessor->setIncludePaths(QStringList(TestIncludePaths::globalIncludePath()));
sourceProcessor->setHeaderPaths(ProjectPart::HeaderPaths()
<< ProjectPart::HeaderPath(
TestIncludePaths::globalIncludePath(),
ProjectPart::HeaderPath::IncludePath));
sourceProcessor->run(fileName);
Document::Ptr document = cmm->document(fileName);
src/plugins/cpptools/modelmanagertesthelper.cpp
+1 -2
View File
@@ -87,8 +87,7 @@ void ModelManagerTestHelper::verifyClean()
assert(mm);
QVERIFY(mm->projectInfos().isEmpty());
QVERIFY(mm->includePaths().isEmpty());
QVERIFY(mm->frameworkPaths().isEmpty());
QVERIFY(mm->headerPaths().isEmpty());
QVERIFY(mm->definedMacros().isEmpty());
QVERIFY(mm->projectFiles().isEmpty());
QVERIFY(mm->snapshot().isEmpty());
src/plugins/genericprojectmanager/genericproject.cpp
+3 -1
View File
@@ -246,7 +246,9 @@ void GenericProject::refresh(RefreshOptions options)
part->displayName = displayName();
part->projectFile = projectFilePath().toString();
part->includePaths += projectIncludePaths();
foreach (const QString &inc, projectIncludePaths())
part->headerPaths += CppTools::ProjectPart::HeaderPath(
inc, CppTools::ProjectPart::HeaderPath::IncludePath);
Kit *k = activeTarget() ? activeTarget()->kit() : KitManager::defaultKit();
if (ToolChain *tc = ToolChainKitInformation::toolChain(k)) {
src/plugins/qbsprojectmanager/qbsproject.cpp
+10 -12
View File
@@ -546,19 +546,18 @@ void QbsProject::updateCppCodeModel(const qbs::ProjectData &prj)
list = props.getModulePropertiesAsStringList(QLatin1String(CONFIG_CPP_MODULE),
QLatin1String(CONFIG_INCLUDEPATHS));
QStringList grpIncludePaths;
foreach (const QString &p, list) {
const QString cp = FileName::fromUserInput(p).toString();
grpIncludePaths.append(cp);
}
CppTools::ProjectPart::HeaderPaths grpHeaderPaths;
foreach (const QString &p, list)
grpHeaderPaths += CppTools::ProjectPart::HeaderPath(
FileName::fromUserInput(p).toString(),
CppTools::ProjectPart::HeaderPath::IncludePath);
list = props.getModulePropertiesAsStringList(QLatin1String(CONFIG_CPP_MODULE),
QLatin1String(CONFIG_FRAMEWORKPATHS));
QStringList grpFrameworkPaths;
foreach (const QString &p, list) {
const QString cp = FileName::fromUserInput(p).toString();
grpFrameworkPaths.append(cp);
}
foreach (const QString &p, list)
grpHeaderPaths += CppTools::ProjectPart::HeaderPath(
FileName::fromUserInput(p).toString(),
CppTools::ProjectPart::HeaderPath::FrameworkPath);
const QString pch = props.getModuleProperty(QLatin1String(CONFIG_CPP_MODULE),
QLatin1String(CONFIG_PRECOMPILEDHEADER)).toString();
@@ -590,8 +589,7 @@ void QbsProject::updateCppCodeModel(const qbs::ProjectData &prj)
CppTools::ProjectFile::CXXHeader);
part->qtVersion = qtVersionForPart;
part->includePaths += grpIncludePaths;
part->frameworkPaths += grpFrameworkPaths;
part->headerPaths += grpHeaderPaths;
part->precompiledHeaders = QStringList(pch);
part->projectDefines += grpDefines;
pinfo.appendProjectPart(part);
src/plugins/qmakeprojectmanager/qmakeproject.cpp
+13 -8
View File
@@ -520,22 +520,27 @@ void QmakeProject::updateCppCodeModel()
// part->defines
part->projectDefines += pro->cxxDefines();
// part->includePaths, part->frameworkPaths
part->includePaths.append(pro->variableValue(IncludePathVar));
// part->headerPaths
foreach (const QString &inc, pro->variableValue(IncludePathVar))
part->headerPaths += ProjectPart::HeaderPath(inc, ProjectPart::HeaderPath::IncludePath);
if (qtVersion) {
foreach (const HeaderPath &header, qtVersion->systemHeaderPathes(k)) {
ProjectPart::HeaderPath::Type type = ProjectPart::HeaderPath::IncludePath;
if (header.kind() == HeaderPath::FrameworkHeaderPath)
part->frameworkPaths.append(header.path());
else
part->includePaths.append(header.path());
type = ProjectPart::HeaderPath::FrameworkPath;
part->headerPaths += ProjectPart::HeaderPath(header.path(), type);
}
if (!qtVersion->frameworkInstallPath().isEmpty()) {
part->headerPaths += ProjectPart::HeaderPath(
qtVersion->frameworkInstallPath(),
ProjectPart::HeaderPath::FrameworkPath);
}
if (!qtVersion->frameworkInstallPath().isEmpty())
part->frameworkPaths.append(qtVersion->frameworkInstallPath());
}
if (QmakeProFileNode *node = rootQmakeProjectNode())
part->includePaths.append(node->resolvedMkspecPath());
part->headerPaths += ProjectPart::HeaderPath(node->resolvedMkspecPath(),
ProjectPart::HeaderPath::IncludePath);
// part->precompiledHeaders
part->precompiledHeaders.append(pro->variableValue(PrecompiledHeaderVar));