feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity
Files
4ad0e5295c9cc5800e170e9dc23585ad53634d24
qt-creator/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp

571 lines
20 KiB
C++
Raw Normal View History

C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
/****************************************************************************
**
Update License according to agreement with Free Qt Foundation * Update files in src/plugins Change-Id: Ia5d77fad7d19d4bb3498e78661982f68729adb22 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:57:40 +01:00
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
**
** 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
Update License according to agreement with Free Qt Foundation * Update files in src/plugins Change-Id: Ia5d77fad7d19d4bb3498e78661982f68729adb22 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:57:40 +01:00
** 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.
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
**
Update License according to agreement with Free Qt Foundation * Update files in src/plugins Change-Id: Ia5d77fad7d19d4bb3498e78661982f68729adb22 Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>
2016-01-15 14:57:40 +01:00
** 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.
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
**
****************************************************************************/
#include "clangeditordocumentprocessor.h"
Clang: Pass IpcCommunicator directly to ClangEditorDocumentProcessor Change-Id: I666c56f304522a3edc2a21055df4ef70aecb0e0e Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-12-15 12:16:25 +01:00
#include "clangbackendipcintegration.h"
Clang: Display also child diagnostics in tooltips ...by introducing a custom tooltip widget for diagnostics. Locations and fixits of child diagnostics are presented as clickable links, leading to that position in the editor or to the execution of that fix it. Change-Id: I83e801e22d0421dd29275e333e5dd91587885cf1 Reviewed-by: Alessandro Portale <alessandro.portale@theqtcompany.com>
2016-01-29 17:17:18 +01:00
#include "clangdiagnostictooltipwidget.h"
Clang: Integrate clang's fixits as refactoring actions They are invokable by the usual means (Alt+Enter, editor's context menu > Refactor) plus by the context menu of the editor's left margin for the related line. The fixit text comes directly from libclang and is thus not translated. We modify the text slighty by stripping the diagnostic category prefix ("note:", "error:", ...) and capitalizing the first letter. A follow-up change should properly indicate available refactorings with a refactoring icon in the editor's left margin. Task-number: QTCREATORBUG-14868 Change-Id: I86157c9f824d2a9dedf19087476d02ad1e6cc854 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-08-24 18:26:09 +02:00
#include "clangfixitoperation.h"
#include "clangfixitoperationsextractor.h"
Clang: Use "clang" prefix plugin files ...for consistency and to avoid future file name clashes. Change-Id: If595c8debfa1ceb01a1bb0ed34649fa513660503 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 09:43:50 +01:00
#include "clanghighlightingmarksreporter.h"
Clang: Introduce warning configuration per project Change-Id: I5b9a330274e6f72b0786259eb25aa454877d4eef Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2016-02-26 17:50:38 +01:00
#include "clangprojectsettings.h"
Clang: Use completion through backend process This makes us independent of libclang crashes for completion. Re-parsing for highlighting still happens in the Qt Creator process. Run in verbose mode: qtc.clangcodemodel.ipc=true Run tests: -test "ClangCodeModel" Task-number: QTCREATORBUG-14108 Task-number: QTCREATORBUG-12819 Change-Id: Id3e95bd2afdb6508bbd1d35fddc69534a909b905 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-05-08 15:48:17 +02:00
#include "clangutils.h"
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
#include <diagnosticcontainer.h>
#include <sourcelocationcontainer.h>
Clang: Introduce warning configuration per project Change-Id: I5b9a330274e6f72b0786259eb25aa454877d4eef Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2016-02-26 17:50:38 +01:00
#include <cpptools/clangdiagnosticconfigsmodel.h>
#include <cpptools/clangdiagnosticconfigsmodel.h>
CppTools: Remove cpptools/cppprojects.[h|cpp] Change-Id: Ida0e8552d371972c141cf561b28667f4428c6fff Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2016-01-12 12:51:33 +01:00
#include <cpptools/compileroptionsbuilder.h>
Clang: Allow to provide extra command line options This can be used to experiment with clang options that e.g. affect diagnostics. Changes take effect on editor re-open. Change-Id: Ie46d0ff085a3700a748dbcf4b94b93b0bf9c4642 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Eike Ziller <eike.ziller@theqtcompany.com>
2015-11-10 16:54:53 +01:00
#include <cpptools/cppcodemodelsettings.h>
CppTools/Clang: Clean-up of includes Change-Id: I0ba340dcf0ee23e61588f17262d07e7088751836 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-12-15 11:59:48 +01:00
#include <cpptools/cppmodelmanager.h>
CppTools: Add CppToolsBridge We broke the dependency of BaseEditorDocumentProcessor *BaseEditorDocumentProcessor::get(const QString &filePath) It's hiding static calls and it is much easier to do it that way than to provide a reference to every user. It's also possible to exchange it with different implementations for different test cases. Change-Id: Ic74699b45948e8b48f7efb6a1b295ba2641b8951 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2016-01-11 20:50:14 +01:00
#include <cpptools/cpptoolsbridge.h>
Clang: Allow to provide extra command line options This can be used to experiment with clang options that e.g. affect diagnostics. Changes take effect on editor re-open. Change-Id: Ie46d0ff085a3700a748dbcf4b94b93b0bf9c4642 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Eike Ziller <eike.ziller@theqtcompany.com>
2015-11-10 16:54:53 +01:00
#include <cpptools/cpptoolsreuse.h>
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
#include <cpptools/cppworkingcopy.h>
Clang: Fix initial document parse with modified content Reproduce with: 1. Create a new class named Foo with the wizard. 2. Close foo.h 3. In foo.cpp, add some class member function. 4. In foo.cpp, trigger the refactoring action "Add public Declaration" for the just defined member function. As a result, foo.h will be opened. ==> While the declaration was added, the header file is not yet reparsed with the new content - this can be verified by setting a custom color for "Function". In this use case, the refactoring action opens the editor and immediately modifies the document (RefactoringFile::apply). Fix by sending the document content along for the very first RegisterTranslationUnitForEditorMessage if the document was already modified. Change-Id: If20615a45b72dd0bef87e1870e403d0b277bc5d6 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-11-22 15:17:42 +01:00
#include <cpptools/editordocumenthandle.h>
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
Clang: Integrate clang's fixits as refactoring actions They are invokable by the usual means (Alt+Enter, editor's context menu > Refactor) plus by the context menu of the editor's left margin for the related line. The fixit text comes directly from libclang and is thus not translated. We modify the text slighty by stripping the diagnostic category prefix ("note:", "error:", ...) and capitalizing the first letter. A follow-up change should properly indicate available refactorings with a refactoring icon in the editor's left margin. Task-number: QTCREATORBUG-14868 Change-Id: I86157c9f824d2a9dedf19087476d02ad1e6cc854 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-08-24 18:26:09 +02:00
#include <texteditor/convenience.h>
TextEditor: Add display settings page link to annotation tool tips Change-Id: I453127693dd1e0b30918333ac6866ac2fca4baa6 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2017-07-21 14:31:21 +02:00
#include <texteditor/displaysettings.h>
TextEditor/Clang: Add font settings for clang diagnostics Change-Id: Iea2b4fabf0f4620b12f88b108eb59c160945c8d8 Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-09-10 14:18:09 +02:00
#include <texteditor/fontsettings.h>
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
#include <texteditor/texteditor.h>
TextEditor/Clang: Add font settings for clang diagnostics Change-Id: Iea2b4fabf0f4620b12f88b108eb59c160945c8d8 Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-09-10 14:18:09 +02:00
#include <texteditor/texteditorconstants.h>
#include <texteditor/texteditorsettings.h>
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
#include <cplusplus/CppDocument.h>
#include <utils/qtcassert.h>
ClangCodeModel: Use Utils::runAsync Avoids global thread pool and is better maintainable Change-Id: I5d5ffe66918a3e0ec95c1ab7c6b9d964f7a8de2f Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2016-02-12 09:46:22 +01:00
#include <utils/runextensions.h>
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
#include <QTextBlock>
Clang: Show info bar for parse errors in header files ...because those errors can lead to a substantial performance/functional regression. The actual diagnostics (possibly with children) are shown as details in the info bar. The info bar can be hidden with the "Do Not Show Again" button. Re-enabling the info bar is possible with the new editor tool bar button. Change-Id: I03394ff8e3c84127946b0b791930b28a385f5a46 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-04 16:23:42 +02:00
#include <QVBoxLayout>
#include <QWidget>
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
namespace ClangCodeModel {
Clang: Use completion through backend process This makes us independent of libclang crashes for completion. Re-parsing for highlighting still happens in the Qt Creator process. Run in verbose mode: qtc.clangcodemodel.ipc=true Run tests: -test "ClangCodeModel" Task-number: QTCREATORBUG-14108 Task-number: QTCREATORBUG-12819 Change-Id: Id3e95bd2afdb6508bbd1d35fddc69534a909b905 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-05-08 15:48:17 +02:00
namespace Internal {
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
Clang: Use completion through backend process This makes us independent of libclang crashes for completion. Re-parsing for highlighting still happens in the Qt Creator process. Run in verbose mode: qtc.clangcodemodel.ipc=true Run tests: -test "ClangCodeModel" Task-number: QTCREATORBUG-14108 Task-number: QTCREATORBUG-12819 Change-Id: Id3e95bd2afdb6508bbd1d35fddc69534a909b905 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-05-08 15:48:17 +02:00
ClangEditorDocumentProcessor::ClangEditorDocumentProcessor(
Clang: Pass IpcCommunicator directly to ClangEditorDocumentProcessor Change-Id: I666c56f304522a3edc2a21055df4ef70aecb0e0e Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-12-15 12:16:25 +01:00
IpcCommunicator &ipcCommunicator,
Clang: Use completion through backend process This makes us independent of libclang crashes for completion. Re-parsing for highlighting still happens in the Qt Creator process. Run in verbose mode: qtc.clangcodemodel.ipc=true Run tests: -test "ClangCodeModel" Task-number: QTCREATORBUG-14108 Task-number: QTCREATORBUG-12819 Change-Id: Id3e95bd2afdb6508bbd1d35fddc69534a909b905 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-05-08 15:48:17 +02:00
TextEditor::TextDocument *document)
CppTools: Break TextDocument dependency of BaseEditorDocumentProcessor BaseEditorDocumentProcessor was holding a TextEditor::TextDocument but only used the QTextDocument and the file path. Change-Id: I349cc95d973adeaf9f94638d84333f592c14e7f9 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2016-01-11 20:40:05 +01:00
: BaseEditorDocumentProcessor(document->document(), document->filePath().toString())
Clang: Provide highlighting for identifier under cursor Change-Id: I80ffe23cbcc84ab7323124581d9dd6afbe974fd0 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2017-06-09 12:19:09 +02:00
, m_document(*document)
Clang: Refactor handling of diagnostics ...by introducing ClangDiagnosticManager and the helper class ClangDiagnosticFilter. ClangDiagnosticManager will get more state in a follow-up change. Change-Id: Id2c312bc897ea41ed67292b56b24dcfb7975ff4a Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-04 12:15:17 +02:00
, m_diagnosticManager(document)
Clang: Pass IpcCommunicator directly to ClangEditorDocumentProcessor Change-Id: I666c56f304522a3edc2a21055df4ef70aecb0e0e Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-12-15 12:16:25 +01:00
, m_ipcCommunicator(ipcCommunicator)
C++: Fix crash after triggering completion and closing editor Fix use-after-free for the following case: 1. Open an editor 2. Trigger a long processing completion (e.g. simulate with QThread::msleep in CppCompletionAssistInterface::getCppSpecifics) 3. ...and immediately close the editor (e.g. with Ctrl+W) 4. Wait until it crashes. The completion thread relied on the BuiltinEditorDocumentParser object, which is deleted once the editor is closed. Fixed by sharing the ownership of that object between the *EditorDocumentProcessor and the completion assist interface. This case came up when doing tests for the bug report below. Task-number: QTCREATORBUG-14991 Change-Id: I0b009229e68fc6b7838740858cdc41a32403fe6f Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-09-01 17:34:07 +02:00
, m_parser(new ClangEditorDocumentParser(document->filePath().toString()))
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
, m_parserRevision(0)
, m_semanticHighlighter(document)
, m_builtinProcessor(document, /*enableSemanticHighlighter=*/ false)
{
Clang: Hook up supportive translation unit on first edit Parsing happens rotationally on the translation units. The recently parsed translation unit is used for completion jobs while the older version is used for parse jobs. Advantages: A1. A completion job cannot be blocked anymore by currently running parse job. A2. Faster triggering of parse jobs. A reparse was triggered about 1650ms after the last keystroke. This is down to 500ms now since we do not have a blocking translation unit for the completion anymore. Disadvantages: D1. Memory consumption is doubled for an edited document. This could be addressed by suspending the second translation unit after some time of inactivity. D2. Setup of the supportive translation unit takes some time. Change-Id: I958c883c01f274530f5482c788c15cd38d6f4c3e Reviewed-by: David Schulz <david.schulz@qt.io>
2016-09-14 16:16:10 +02:00
m_updateTranslationUnitTimer.setSingleShot(true);
m_updateTranslationUnitTimer.setInterval(350);
connect(&m_updateTranslationUnitTimer, &QTimer::timeout,
this, &ClangEditorDocumentProcessor::updateTranslationUnitIfProjectPartExists);
CppTools: Provide hints about chosen project part for editor document Parse issues can have multiple reasons (invalid kit, not a project file, actual parse issue) and we should be able to tell them apart. With this change, we can distinguish between the fallback project part and a ambiguous project part. Follow up changes will use this to display more accurate diagnostics. Change-Id: Icc8767607cc17dc14d6227b07f34e81ba5525a96 Reviewed-by: David Schulz <david.schulz@qt.io>
2017-01-17 15:27:31 +01:00
connect(m_parser.data(), &ClangEditorDocumentParser::projectPartInfoUpdated,
this, &BaseEditorDocumentProcessor::projectPartInfoUpdated);
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
// Forwarding the semantic info from the builtin processor enables us to provide all
// editor (widget) related features that are not yet implemented by the clang plugin.
connect(&m_builtinProcessor, &CppTools::BuiltinEditorDocumentProcessor::cppDocumentUpdated,
this, &ClangEditorDocumentProcessor::cppDocumentUpdated);
connect(&m_builtinProcessor, &CppTools::BuiltinEditorDocumentProcessor::semanticInfoUpdated,
this, &ClangEditorDocumentProcessor::semanticInfoUpdated);
}
ClangEditorDocumentProcessor::~ClangEditorDocumentProcessor()
{
Clang: Hook up supportive translation unit on first edit Parsing happens rotationally on the translation units. The recently parsed translation unit is used for completion jobs while the older version is used for parse jobs. Advantages: A1. A completion job cannot be blocked anymore by currently running parse job. A2. Faster triggering of parse jobs. A reparse was triggered about 1650ms after the last keystroke. This is down to 500ms now since we do not have a blocking translation unit for the completion anymore. Disadvantages: D1. Memory consumption is doubled for an edited document. This could be addressed by suspending the second translation unit after some time of inactivity. D2. Setup of the supportive translation unit takes some time. Change-Id: I958c883c01f274530f5482c788c15cd38d6f4c3e Reviewed-by: David Schulz <david.schulz@qt.io>
2016-09-14 16:16:10 +02:00
m_updateTranslationUnitTimer.stop();
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
m_parserWatcher.cancel();
m_parserWatcher.waitForFinished();
Clang: Use completion through backend process This makes us independent of libclang crashes for completion. Re-parsing for highlighting still happens in the Qt Creator process. Run in verbose mode: qtc.clangcodemodel.ipc=true Run tests: -test "ClangCodeModel" Task-number: QTCREATORBUG-14108 Task-number: QTCREATORBUG-12819 Change-Id: Id3e95bd2afdb6508bbd1d35fddc69534a909b905 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-05-08 15:48:17 +02:00
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
if (m_projectPart) {
Clang: Pass IpcCommunicator directly to ClangEditorDocumentProcessor Change-Id: I666c56f304522a3edc2a21055df4ef70aecb0e0e Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-12-15 12:16:25 +01:00
m_ipcCommunicator.unregisterTranslationUnitsForEditor(
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
{ClangBackEnd::FileContainer(filePath(), m_projectPart->id())});
}
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
}
CppTools: Remove some duplication Change-Id: I8c84660b28c3e76b2cedd08ff3b44a38583f38a0 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-12-14 18:58:23 +01:00
void ClangEditorDocumentProcessor::runImpl(
const CppTools::BaseEditorDocumentParser::UpdateParams &updateParams)
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
{
Clang: Hook up supportive translation unit on first edit Parsing happens rotationally on the translation units. The recently parsed translation unit is used for completion jobs while the older version is used for parse jobs. Advantages: A1. A completion job cannot be blocked anymore by currently running parse job. A2. Faster triggering of parse jobs. A reparse was triggered about 1650ms after the last keystroke. This is down to 500ms now since we do not have a blocking translation unit for the completion anymore. Disadvantages: D1. Memory consumption is doubled for an edited document. This could be addressed by suspending the second translation unit after some time of inactivity. D2. Setup of the supportive translation unit takes some time. Change-Id: I958c883c01f274530f5482c788c15cd38d6f4c3e Reviewed-by: David Schulz <david.schulz@qt.io>
2016-09-14 16:16:10 +02:00
m_updateTranslationUnitTimer.start();
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
// Run clang parser
disconnect(&m_parserWatcher, &QFutureWatcher<void>::finished,
this, &ClangEditorDocumentProcessor::onParserFinished);
m_parserWatcher.cancel();
m_parserWatcher.setFuture(QFuture<void>());
m_parserRevision = revision();
connect(&m_parserWatcher, &QFutureWatcher<void>::finished,
this, &ClangEditorDocumentProcessor::onParserFinished);
CppTools: Remove some duplication Change-Id: I8c84660b28c3e76b2cedd08ff3b44a38583f38a0 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-12-14 18:58:23 +01:00
const QFuture<void> future = ::Utils::runAsync(&runParser, parser(), updateParams);
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
m_parserWatcher.setFuture(future);
// Run builtin processor
CppTools: Reparse editor documents after active project change Change-Id: I010709c866291bf59c27f4a05765e1ab0efd28af Reviewed-by: David Schulz <david.schulz@qt.io>
2016-12-15 11:21:44 +01:00
m_builtinProcessor.runImpl(updateParams);
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
}
C++: Rename semanticRehighlight to recalculateSemanticInfoDetached semanticRehighlight() does a bit more than only rehighlighting and we want to trigger (only) rehighlighting in a follow-up change. Change-Id: Ic8da9ec8643f0f82f7c99ef9a8180b2868194254 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-06-19 14:37:26 +02:00
void ClangEditorDocumentProcessor::recalculateSemanticInfoDetached(bool force)
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
{
C++: Rename semanticRehighlight to recalculateSemanticInfoDetached semanticRehighlight() does a bit more than only rehighlighting and we want to trigger (only) rehighlighting in a follow-up change. Change-Id: Ic8da9ec8643f0f82f7c99ef9a8180b2868194254 Reviewed-by: Orgad Shaneh <orgads@gmail.com>
2015-06-19 14:37:26 +02:00
m_builtinProcessor.recalculateSemanticInfoDetached(force);
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
}
CppEditor: Fix semantic highlighting when zooming ...for the not visible documents. First reset the extra additional formats, then set the new ones, not the other way around. Task-number: QTCREATORBUG-14579 Change-Id: Iae465bd9a7bb0a397fd4917df45955713aaf87c5 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-06-19 14:43:41 +02:00
void ClangEditorDocumentProcessor::semanticRehighlight()
{
m_semanticHighlighter.updateFormatMapFromFontSettings();
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
if (m_projectPart)
requestDocumentAnnotations(m_projectPart->id());
CppEditor: Fix semantic highlighting when zooming ...for the not visible documents. First reset the extra additional formats, then set the new ones, not the other way around. Task-number: QTCREATORBUG-14579 Change-Id: Iae465bd9a7bb0a397fd4917df45955713aaf87c5 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-06-19 14:43:41 +02:00
}
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
CppTools::SemanticInfo ClangEditorDocumentProcessor::recalculateSemanticInfo()
{
return m_builtinProcessor.recalculateSemanticInfo();
}
C++: Fix crash after triggering completion and closing editor Fix use-after-free for the following case: 1. Open an editor 2. Trigger a long processing completion (e.g. simulate with QThread::msleep in CppCompletionAssistInterface::getCppSpecifics) 3. ...and immediately close the editor (e.g. with Ctrl+W) 4. Wait until it crashes. The completion thread relied on the BuiltinEditorDocumentParser object, which is deleted once the editor is closed. Fixed by sharing the ownership of that object between the *EditorDocumentProcessor and the completion assist interface. This case came up when doing tests for the bug report below. Task-number: QTCREATORBUG-14991 Change-Id: I0b009229e68fc6b7838740858cdc41a32403fe6f Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-09-01 17:34:07 +02:00
CppTools::BaseEditorDocumentParser::Ptr ClangEditorDocumentProcessor::parser()
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
{
C++: Fix crash after triggering completion and closing editor Fix use-after-free for the following case: 1. Open an editor 2. Trigger a long processing completion (e.g. simulate with QThread::msleep in CppCompletionAssistInterface::getCppSpecifics) 3. ...and immediately close the editor (e.g. with Ctrl+W) 4. Wait until it crashes. The completion thread relied on the BuiltinEditorDocumentParser object, which is deleted once the editor is closed. Fixed by sharing the ownership of that object between the *EditorDocumentProcessor and the completion assist interface. This case came up when doing tests for the bug report below. Task-number: QTCREATORBUG-14991 Change-Id: I0b009229e68fc6b7838740858cdc41a32403fe6f Reviewed-by: David Schulz <david.schulz@theqtcompany.com>
2015-09-01 17:34:07 +02:00
return m_parser;
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
}
CppTools: Fix include hierarchy for clang code model This makes the editor document snapshot accessible through BaseEditorDocumentProcessor since we need it for the include hierarchy if the the clang code model is activated. Task-number: QTCREATORBUG-13553 Change-Id: I7214cc578d05fe5cad6e12b4d29fe6f840a88e8d Reviewed-by: Erik Verbruggen <erik.verbruggen@theqtcompany.com>
2014-11-28 12:03:58 +01:00
CPlusPlus::Snapshot ClangEditorDocumentProcessor::snapshot()
{
return m_builtinProcessor.snapshot();
}
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
bool ClangEditorDocumentProcessor::isParserRunning() const
{
return m_parserWatcher.isRunning();
}
Clang: Add ClangEditorDocumentProcessor::hasProjectPart Change-Id: Ie08c44315c9d03434384a1fa0b276e22f45a2107 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-09-28 15:15:25 +02:00
bool ClangEditorDocumentProcessor::hasProjectPart() const
{
return m_projectPart;
}
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
CppTools::ProjectPart::Ptr ClangEditorDocumentProcessor::projectPart() const
{
return m_projectPart;
}
Clang: Unregister file with project immediately on project close Ensure that first the editors unregister with the removed project part, then unregister the project part. This makes testing and following the message logs easier. It also fixes the following race condition: * Unload project of opened file * Immediately close the editor before a new project part is calculated ==> The editor is closed, but the translation unit is not properly unregistered. Change-Id: I618930d221323435ba60ac6c051380bccc9fdaf1 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-18 12:19:46 +02:00
void ClangEditorDocumentProcessor::clearProjectPart()
{
m_projectPart.clear();
}
Clang: Show info bar for parse errors in header files ...because those errors can lead to a substantial performance/functional regression. The actual diagnostics (possibly with children) are shown as details in the info bar. The info bar can be hidden with the "Do Not Show Again" button. Re-enabling the info bar is possible with the new editor tool bar button. Change-Id: I03394ff8e3c84127946b0b791930b28a385f5a46 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-04 16:23:42 +02:00
void ClangEditorDocumentProcessor::updateCodeWarnings(
const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
const ClangBackEnd::DiagnosticContainer &firstHeaderErrorDiagnostic,
uint documentRevision)
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
{
if (documentRevision == revision()) {
Clang: Show inline diagnostics only for project files When navigating to headers that are not part of the project, avoid showing the inline diagnostics. In most cases, these files can't be changed. This helps also for the session-load case where files are opened/parsed when no project information is available yet. Change-Id: I7fce24af78b3b1efbf64dd27d8ca2a053e02d4ec Reviewed-by: David Schulz <david.schulz@qt.io>
2017-07-10 09:53:34 +02:00
m_diagnosticManager.processNewDiagnostics(diagnostics, m_isProjectFile);
Clang: Refactor handling of diagnostics ...by introducing ClangDiagnosticManager and the helper class ClangDiagnosticFilter. ClangDiagnosticManager will get more state in a follow-up change. Change-Id: Id2c312bc897ea41ed67292b56b24dcfb7975ff4a Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-04 12:15:17 +02:00
const auto codeWarnings = m_diagnosticManager.takeExtraSelections();
Clang: Indicate available "fix its" with a light bulb ...at the end of the line, just like for the "Apply Function Signature Changes" refactor action. * Hovering the light bulb shows the tooltip "Inspect available fixits". * Clicking the light bulb leads to the refactoring menu, as if the user hit Alt+Return. Change-Id: Iaf7b3734c43e21fc28e6b0658f517d98858c0e0c Reviewed-by: Alessandro Portale <alessandro.portale@theqtcompany.com>
2016-02-05 15:16:02 +01:00
const auto fixitAvailableMarkers = m_diagnosticManager.takeFixItAvailableMarkers();
Clang: Show info bar for parse errors in header files ...because those errors can lead to a substantial performance/functional regression. The actual diagnostics (possibly with children) are shown as details in the info bar. The info bar can be hidden with the "Do Not Show Again" button. Re-enabling the info bar is possible with the new editor tool bar button. Change-Id: I03394ff8e3c84127946b0b791930b28a385f5a46 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-04 16:23:42 +02:00
const auto creator = creatorForHeaderErrorDiagnosticWidget(firstHeaderErrorDiagnostic);
emit codeWarningsUpdated(revision(),
codeWarnings,
creator,
fixitAvailableMarkers);
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
}
}
Clang: Use line and column instead of offset for diagnostics Offsets can be get wrong because of the utf8 <-> utf16 differences. Line and columns are not that sensitive to it. Change-Id: I2e3e8c000621b6d694a4ada6df176f29427794f5 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-12-02 20:07:29 +01:00
namespace {
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
Clang: Use line and column instead of offset for diagnostics Offsets can be get wrong because of the utf8 <-> utf16 differences. Line and columns are not that sensitive to it. Change-Id: I2e3e8c000621b6d694a4ada6df176f29427794f5 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-12-02 20:07:29 +01:00
int positionInText(QTextDocument *textDocument,
const ClangBackEnd::SourceLocationContainer &sourceLocationContainer)
{
auto textBlock = textDocument->findBlockByNumber(int(sourceLocationContainer.line()) - 1);
return textBlock.position() + int(sourceLocationContainer.column()) - 1;
}
TextEditor::BlockRange
toTextEditorBlock(QTextDocument *textDocument,
const ClangBackEnd::SourceRangeContainer &sourceRangeContainer)
{
return TextEditor::BlockRange(positionInText(textDocument, sourceRangeContainer.start()),
positionInText(textDocument, sourceRangeContainer.end()));
}
QList<TextEditor::BlockRange>
toTextEditorBlocks(QTextDocument *textDocument,
const QVector<ClangBackEnd::SourceRangeContainer> &ifdefedOutRanges)
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
{
QList<TextEditor::BlockRange> blockRanges;
blockRanges.reserve(ifdefedOutRanges.size());
for (const auto &range : ifdefedOutRanges)
Clang: Use line and column instead of offset for diagnostics Offsets can be get wrong because of the utf8 <-> utf16 differences. Line and columns are not that sensitive to it. Change-Id: I2e3e8c000621b6d694a4ada6df176f29427794f5 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-12-02 20:07:29 +01:00
blockRanges.append(toTextEditorBlock(textDocument, range));
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
return blockRanges;
}
Clang: Use line and column instead of offset for diagnostics Offsets can be get wrong because of the utf8 <-> utf16 differences. Line and columns are not that sensitive to it. Change-Id: I2e3e8c000621b6d694a4ada6df176f29427794f5 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-12-02 20:07:29 +01:00
}
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
void ClangEditorDocumentProcessor::updateHighlighting(
const QVector<ClangBackEnd::HighlightingMarkContainer> &highlightingMarks,
const QVector<ClangBackEnd::SourceRangeContainer> &skippedPreprocessorRanges,
uint documentRevision)
{
if (documentRevision == revision()) {
Clang: Use line and column instead of offset for diagnostics Offsets can be get wrong because of the utf8 <-> utf16 differences. Line and columns are not that sensitive to it. Change-Id: I2e3e8c000621b6d694a4ada6df176f29427794f5 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-12-02 20:07:29 +01:00
const auto skippedPreprocessorBlocks = toTextEditorBlocks(textDocument(), skippedPreprocessorRanges);
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
emit ifdefedOutBlocksUpdated(documentRevision, skippedPreprocessorBlocks);
m_semanticHighlighter.setHighlightingRunner(
[highlightingMarks]() {
auto *reporter = new HighlightingMarksReporter(highlightingMarks);
return reporter->start();
});
m_semanticHighlighter.run();
}
}
Clang: Integrate clang's fixits as refactoring actions They are invokable by the usual means (Alt+Enter, editor's context menu > Refactor) plus by the context menu of the editor's left margin for the related line. The fixit text comes directly from libclang and is thus not translated. We modify the text slighty by stripping the diagnostic category prefix ("note:", "error:", ...) and capitalizing the first letter. A follow-up change should properly indicate available refactorings with a refactoring icon in the editor's left margin. Task-number: QTCREATORBUG-14868 Change-Id: I86157c9f824d2a9dedf19087476d02ad1e6cc854 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-08-24 18:26:09 +02:00
static int currentLine(const TextEditor::AssistInterface &assistInterface)
{
int line, column;
TextEditor::Convenience::convertPosition(assistInterface.textDocument(),
assistInterface.position(),
&line,
&column);
return line;
}
TextEditor::QuickFixOperations ClangEditorDocumentProcessor::extraRefactoringOperations(
const TextEditor::AssistInterface &assistInterface)
{
ClangFixItOperationsExtractor extractor(m_diagnosticManager.diagnosticsWithFixIts());
return extractor.extract(assistInterface.fileName(), currentLine(assistInterface));
}
Clang: Use CppHoverHandler for diagnostic tooltips We used to call QTextCharFormat::setToolTip from the ExtraSelection to install the diagnostic tooltip. Since this allows to set only text tooltips and we would like to introduce a custom tooltip widget for diagnostics, make use of CppHoverHandler, which is more flexible. Change-Id: Ia1b2c3c50810596ce4a3a025002e6e4efd8789db Reviewed-by: Alessandro Portale <alessandro.portale@theqtcompany.com>
2016-01-27 13:37:19 +01:00
bool ClangEditorDocumentProcessor::hasDiagnosticsAt(uint line, uint column) const
{
return m_diagnosticManager.hasDiagnosticsAt(line, column);
}
CppEditor: Use full tooltip in ClangTextMark Change-Id: I39cc64acbdbcd5e5156e1514acaf9674a91e81a4 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2016-07-22 08:57:32 +02:00
void ClangEditorDocumentProcessor::addDiagnosticToolTipToLayout(uint line,
uint column,
QLayout *target) const
Clang: Use CppHoverHandler for diagnostic tooltips We used to call QTextCharFormat::setToolTip from the ExtraSelection to install the diagnostic tooltip. Since this allows to set only text tooltips and we would like to introduce a custom tooltip widget for diagnostics, make use of CppHoverHandler, which is more flexible. Change-Id: Ia1b2c3c50810596ce4a3a025002e6e4efd8789db Reviewed-by: Alessandro Portale <alessandro.portale@theqtcompany.com>
2016-01-27 13:37:19 +01:00
{
Clang: Clean up diagnostic widget * Use a single QLabel - No need for all the QLabels we used. Also, a single QLabel enables selecting and copying all the diagnostics, which is handy when displayed in the info bar. * Avoid call to Utils::ToolTip::hideImmediately() if the location is clicked from the info bar. * Simplify code and API Change-Id: Ib991364e4d6f40ef02dada8ebbb90fe6ff8ae1a1 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io> Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-18 18:01:57 +02:00
using Internal::ClangDiagnosticWidget;
const QVector<ClangBackEnd::DiagnosticContainer> diagnostics
= m_diagnosticManager.diagnosticsAt(line, column);
target->addWidget(ClangDiagnosticWidget::create(diagnostics, ClangDiagnosticWidget::ToolTip));
TextEditor: Add display settings page link to annotation tool tips Change-Id: I453127693dd1e0b30918333ac6866ac2fca4baa6 Reviewed-by: Christian Stenger <christian.stenger@qt.io>
2017-07-21 14:31:21 +02:00
auto link = TextEditor::DisplaySettings::createAnnotationSettingsLink();
target->addWidget(link);
target->setAlignment(link, Qt::AlignRight);
Clang: Use CppHoverHandler for diagnostic tooltips We used to call QTextCharFormat::setToolTip from the ExtraSelection to install the diagnostic tooltip. Since this allows to set only text tooltips and we would like to introduce a custom tooltip widget for diagnostics, make use of CppHoverHandler, which is more flexible. Change-Id: Ia1b2c3c50810596ce4a3a025002e6e4efd8789db Reviewed-by: Alessandro Portale <alessandro.portale@theqtcompany.com>
2016-01-27 13:37:19 +01:00
}
Clang: Hook up supportive translation unit on first edit Parsing happens rotationally on the translation units. The recently parsed translation unit is used for completion jobs while the older version is used for parse jobs. Advantages: A1. A completion job cannot be blocked anymore by currently running parse job. A2. Faster triggering of parse jobs. A reparse was triggered about 1650ms after the last keystroke. This is down to 500ms now since we do not have a blocking translation unit for the completion anymore. Disadvantages: D1. Memory consumption is doubled for an edited document. This could be addressed by suspending the second translation unit after some time of inactivity. D2. Setup of the supportive translation unit takes some time. Change-Id: I958c883c01f274530f5482c788c15cd38d6f4c3e Reviewed-by: David Schulz <david.schulz@qt.io>
2016-09-14 16:16:10 +02:00
void ClangEditorDocumentProcessor::editorDocumentTimerRestarted()
{
m_updateTranslationUnitTimer.stop(); // Wait for the next call to run().
}
Clang: Gray out diagnostics on document change When reparses take a while, this is helpful. Change-Id: Ie2003a3d65b30d944d20fa19dd4161412182851c Reviewed-by: David Schulz <david.schulz@qt.io>
2017-07-03 13:29:30 +02:00
void ClangEditorDocumentProcessor::invalidateDiagnostics()
{
m_diagnosticManager.invalidateDiagnostics();
}
CppEditor: Rework showing/switching parse configurations * Move the combox box for switching the parse configurations out of the "Additional Preprocessor Directives" dialog ('#'-button) to make it better visible/accessible. Also, decouple the extra preprocessor directives from the concrete parse context since this is not anymore in same dialog. * The combo box appears only if multiple parse configurations are available for a file. * The first time multiple parse configurations are detected, an info bar is shown that points the user to the combox box. A "Do Not Show Again" button is provided. * Upon selecting an entry, the preferred parse configuration is saved as part of the session. The setting can be cleared with the context menu entry on the combo box. Follow-up changes need to ensure that the display name and/or tooltip is unambiguous, e.g. for qbs and cmake projects. Change-Id: I9e9773704187291524ad7b605bfdddd83ef5b19d Reviewed-by: David Schulz <david.schulz@qt.io>
2017-01-18 15:05:46 +01:00
void ClangEditorDocumentProcessor::setParserConfig(
const CppTools::BaseEditorDocumentParser::Configuration config)
{
m_parser->setConfiguration(config);
m_builtinProcessor.parser()->setConfiguration(config);
}
Clang: Provide highlighting for identifier under cursor Change-Id: I80ffe23cbcc84ab7323124581d9dd6afbe974fd0 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2017-06-09 12:19:09 +02:00
static bool isCursorOnIdentifier(const QTextCursor &textCursor)
{
QTextDocument *document = textCursor.document();
return CppTools::isValidIdentifierChar(document->characterAt(textCursor.position()));
}
static QFuture<CppTools::CursorInfo> defaultCursorInfoFuture()
{
QFutureInterface<CppTools::CursorInfo> futureInterface;
futureInterface.reportResult(CppTools::CursorInfo());
futureInterface.reportFinished();
return futureInterface.future();
}
static bool convertPosition(const QTextCursor &textCursor, int *line, int *column)
{
const bool converted = TextEditor::Convenience::convertPosition(textCursor.document(),
textCursor.position(),
line,
column);
QTC_CHECK(converted);
return converted;
}
CppEditor: Generalize CppUseSelectionsUpdater Let CppUseSelectionsUpdater delegate the work to *EditorDocumentProcessor so that the clang code model can also provide results. Change-Id: I6872afbfeea1a5c4a64fdf19fcb1992f134dde08 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2017-05-24 13:23:01 +02:00
QFuture<CppTools::CursorInfo>
ClangEditorDocumentProcessor::cursorInfo(const CppTools::CursorInfoParams &params)
{
Clang: Provide highlighting for identifier under cursor Change-Id: I80ffe23cbcc84ab7323124581d9dd6afbe974fd0 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2017-06-09 12:19:09 +02:00
int line, column;
convertPosition(params.textCursor, &line, &column);
++column; // for 1-based columns
if (!isCursorOnIdentifier(params.textCursor))
return defaultCursorInfoFuture();
const QTextBlock block = params.textCursor.document()->findBlockByNumber(line - 1);
column += ClangCodeModel::Utils::extraUtf8CharsShift(block.text(), column);
return m_ipcCommunicator.requestReferences(simpleFileContainer(),
static_cast<quint32>(line),
static_cast<quint32>(column),
textDocument());
CppEditor: Generalize CppUseSelectionsUpdater Let CppUseSelectionsUpdater delegate the work to *EditorDocumentProcessor so that the clang code model can also provide results. Change-Id: I6872afbfeea1a5c4a64fdf19fcb1992f134dde08 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2017-05-24 13:23:01 +02:00
}
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
ClangBackEnd::FileContainer ClangEditorDocumentProcessor::fileContainerWithArguments() const
Clang: Add fileContainer getter File containers were generates in many places. To reduce the noise this getters are introduced. Change-Id: I059745c27ac2dd0515bc23b3438d6d264ba071d7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-10-05 11:17:03 +02:00
{
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
return fileContainerWithArguments(m_projectPart.data());
Clang: Add fileContainer getter File containers were generates in many places. To reduce the noise this getters are introduced. Change-Id: I059745c27ac2dd0515bc23b3438d6d264ba071d7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-10-05 11:17:03 +02:00
}
Clang: Only apply fixits to the corresponding revision Change-Id: I4f4136369e1b261338d444670c212565e0c6b824 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-11-25 15:11:23 +01:00
void ClangEditorDocumentProcessor::clearDiagnosticsWithFixIts()
{
m_diagnosticManager.clearDiagnosticsWithFixIts();
}
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
ClangEditorDocumentProcessor *ClangEditorDocumentProcessor::get(const QString &filePath)
{
CppTools: Add CppToolsBridge We broke the dependency of BaseEditorDocumentProcessor *BaseEditorDocumentProcessor::get(const QString &filePath) It's hiding static calls and it is much easier to do it that way than to provide a reference to every user. It's also possible to exchange it with different implementations for different test cases. Change-Id: Ic74699b45948e8b48f7efb6a1b295ba2641b8951 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2016-01-11 20:50:14 +01:00
auto *processor = CppTools::CppToolsBridge::baseEditorDocumentProcessor(filePath);
return qobject_cast<ClangEditorDocumentProcessor*>(processor);
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
}
Clang: Fix race condition when closing a project ...which could lead to undesired asserts: SOFT ASSERT: "!"Got ProjectPartsDoNotExistMessage"" in file clangbackendipcintegration.cpp, line 184 Change-Id: If6d67b9f617394ce8f72e7e56699423d47879688 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-24 12:17:43 +02:00
static bool isProjectPartLoadedOrIsFallback(CppTools::ProjectPart::Ptr projectPart)
{
return projectPart
Clang: Rename isProjectPartValid to isProjectPartLoaded Change-Id: Ib20700ebb7142cfa9e75edff3b21410fd3bdab05 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-24 14:25:53 +02:00
&& (projectPart->id().isEmpty() || ClangCodeModel::Utils::isProjectPartLoaded(projectPart));
Clang: Fix race condition when closing a project ...which could lead to undesired asserts: SOFT ASSERT: "!"Got ProjectPartsDoNotExistMessage"" in file clangbackendipcintegration.cpp, line 184 Change-Id: If6d67b9f617394ce8f72e7e56699423d47879688 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-24 12:17:43 +02:00
}
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
void ClangEditorDocumentProcessor::updateProjectPartAndTranslationUnitForEditor()
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
{
CppTools: Provide hints about chosen project part for editor document Parse issues can have multiple reasons (invalid kit, not a project file, actual parse issue) and we should be able to tell them apart. With this change, we can distinguish between the fallback project part and a ambiguous project part. Follow up changes will use this to display more accurate diagnostics. Change-Id: Icc8767607cc17dc14d6227b07f34e81ba5525a96 Reviewed-by: David Schulz <david.schulz@qt.io>
2017-01-17 15:27:31 +01:00
const CppTools::ProjectPart::Ptr projectPart = m_parser->projectPartInfo().projectPart;
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
Clang: Fix race condition when closing a project ...which could lead to undesired asserts: SOFT ASSERT: "!"Got ProjectPartsDoNotExistMessage"" in file clangbackendipcintegration.cpp, line 184 Change-Id: If6d67b9f617394ce8f72e7e56699423d47879688 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-24 12:17:43 +02:00
if (isProjectPartLoadedOrIsFallback(projectPart)) {
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
registerTranslationUnitForEditor(projectPart.data());
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
Clang: Fix race condition when closing a project ...which could lead to undesired asserts: SOFT ASSERT: "!"Got ProjectPartsDoNotExistMessage"" in file clangbackendipcintegration.cpp, line 184 Change-Id: If6d67b9f617394ce8f72e7e56699423d47879688 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-24 12:17:43 +02:00
m_projectPart = projectPart;
Clang: Show inline diagnostics only for project files When navigating to headers that are not part of the project, avoid showing the inline diagnostics. In most cases, these files can't be changed. This helps also for the session-load case where files are opened/parsed when no project information is available yet. Change-Id: I7fce24af78b3b1efbf64dd27d8ca2a053e02d4ec Reviewed-by: David Schulz <david.schulz@qt.io>
2017-07-10 09:53:34 +02:00
m_isProjectFile = m_parser->projectPartInfo().hints
& CppTools::ProjectPartInfo::IsFromProjectMatch;
Clang: Fix race condition when closing a project ...which could lead to undesired asserts: SOFT ASSERT: "!"Got ProjectPartsDoNotExistMessage"" in file clangbackendipcintegration.cpp, line 184 Change-Id: If6d67b9f617394ce8f72e7e56699423d47879688 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-09-24 12:17:43 +02:00
}
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
}
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
void ClangEditorDocumentProcessor::onParserFinished()
{
if (revision() != m_parserRevision)
return;
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
updateProjectPartAndTranslationUnitForEditor();
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
}
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
void ClangEditorDocumentProcessor::registerTranslationUnitForEditor(CppTools::ProjectPart *projectPart)
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
{
Clang: Avoid pointless preamble regeneration on Windows ...on first user modification of the document by ensuring that libclang sees only one kind of line separators. This reduces the latency for the very first completion. Change-Id: I9fdd5641e673a5d07200d61476d56d01db62b89e Reviewed-by: David Schulz <david.schulz@qt.io>
2017-02-27 13:10:19 +01:00
// On registration we send the document content immediately as an unsaved
// file, because
// (1) a refactoring action might have opened and already modified
// this document.
// (2) it prevents an extra preamble generation on first user
// modification of the document in case the line endings on disk
// differ from the ones returned by textDocument()->toPlainText(),
// like on Windows.
Clang: Fix sending (un)register translation unit Handle the following use cases: 1. Editor is opened --> Register file at backend. 2. Close editor for which a project part exists --> Unregister file with project part. 3. Close editor for which no project part exists (anymore) --> Unregister file with empty/default project part. Change-Id: I2b253004a920cccef989876538ab552eacf6b45c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-07-14 19:01:32 +02:00
if (m_projectPart) {
Clang: Avoid pointless preamble regeneration on Windows ...on first user modification of the document by ensuring that libclang sees only one kind of line separators. This reduces the latency for the very first completion. Change-Id: I9fdd5641e673a5d07200d61476d56d01db62b89e Reviewed-by: David Schulz <david.schulz@qt.io>
2017-02-27 13:10:19 +01:00
if (projectPart->id() == m_projectPart->id())
return;
m_ipcCommunicator.unregisterTranslationUnitsForEditor({fileContainerWithArguments()});
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
}
Clang: Avoid pointless preamble regeneration on Windows ...on first user modification of the document by ensuring that libclang sees only one kind of line separators. This reduces the latency for the very first completion. Change-Id: I9fdd5641e673a5d07200d61476d56d01db62b89e Reviewed-by: David Schulz <david.schulz@qt.io>
2017-02-27 13:10:19 +01:00
m_ipcCommunicator.registerTranslationUnitsForEditor(
{fileContainerWithArgumentsAndDocumentContent(projectPart)});
ClangCodeModel::Utils::setLastSentDocumentRevision(filePath(), revision());
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
}
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
void ClangEditorDocumentProcessor::updateTranslationUnitIfProjectPartExists()
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
{
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
if (m_projectPart) {
const ClangBackEnd::FileContainer fileContainer = fileContainerWithDocumentContent(m_projectPart->id());
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
Clang: Pass IpcCommunicator directly to ClangEditorDocumentProcessor Change-Id: I666c56f304522a3edc2a21055df4ef70aecb0e0e Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-12-15 12:16:25 +01:00
m_ipcCommunicator.updateTranslationUnitWithRevisionCheck(fileContainer);
Clang: Add diagnostics Diagnostics are now moved to the clang backend process. Fixits are supported too. Change-Id: I20faacf466bbf78dec479220c3d7b336a47bc453 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-08-31 16:28:26 +02:00
}
}
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
void ClangEditorDocumentProcessor::requestDocumentAnnotations(const QString &projectpartId)
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
{
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
const auto fileContainer = fileContainerWithDocumentContent(projectpartId);
Clang: Integrate highlighting results from backend Change-Id: I2c3fb69aabfe075bde76d63eafc2ca370f17493c Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-18 17:07:44 +01:00
Clang: Merge highlighting/diagnostics messages The messages RequestDiagnosticsMessage RequestHighlightingMessage and DiagnosticsChangedMessage HighlightingChangedMessage are always send/received together, so merge them into RequestDocumentAnnotationsMessage DocumentAnnotationsChangedMessage Change-Id: I6a0b6281ed1e6efe6cb18386afe99b1d1fb58abf Reviewed-by: Marco Bubke <marco.bubke@qt.io> Reviewed-by: Thomas Hartmann <Thomas.Hartmann@theqtcompany.com>
2016-06-09 12:55:42 +02:00
m_ipcCommunicator.requestDocumentAnnotations(fileContainer);
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
}
Clang: Show info bar for parse errors in header files ...because those errors can lead to a substantial performance/functional regression. The actual diagnostics (possibly with children) are shown as details in the info bar. The info bar can be hidden with the "Do Not Show Again" button. Re-enabling the info bar is possible with the new editor tool bar button. Change-Id: I03394ff8e3c84127946b0b791930b28a385f5a46 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-04 16:23:42 +02:00
CppTools::BaseEditorDocumentProcessor::HeaderErrorDiagnosticWidgetCreator
ClangEditorDocumentProcessor::creatorForHeaderErrorDiagnosticWidget(
const ClangBackEnd::DiagnosticContainer &firstHeaderErrorDiagnostic)
{
if (firstHeaderErrorDiagnostic.text().isEmpty())
return CppTools::BaseEditorDocumentProcessor::HeaderErrorDiagnosticWidgetCreator();
return [firstHeaderErrorDiagnostic]() {
auto vbox = new QVBoxLayout;
vbox->setMargin(0);
vbox->setContentsMargins(10, 0, 0, 2);
vbox->setSpacing(2);
Clang: Clean up diagnostic widget * Use a single QLabel - No need for all the QLabels we used. Also, a single QLabel enables selecting and copying all the diagnostics, which is handy when displayed in the info bar. * Avoid call to Utils::ToolTip::hideImmediately() if the location is clicked from the info bar. * Simplify code and API Change-Id: Ib991364e4d6f40ef02dada8ebbb90fe6ff8ae1a1 Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io> Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-18 18:01:57 +02:00
vbox->addWidget(ClangDiagnosticWidget::create({firstHeaderErrorDiagnostic},
ClangDiagnosticWidget::InfoBar));
Clang: Show info bar for parse errors in header files ...because those errors can lead to a substantial performance/functional regression. The actual diagnostics (possibly with children) are shown as details in the info bar. The info bar can be hidden with the "Do Not Show Again" button. Re-enabling the info bar is possible with the new editor tool bar button. Change-Id: I03394ff8e3c84127946b0b791930b28a385f5a46 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-10-04 16:23:42 +02:00
auto widget = new QWidget;
widget->setLayout(vbox);
return widget;
};
}
Clang: Provide highlighting for identifier under cursor Change-Id: I80ffe23cbcc84ab7323124581d9dd6afbe974fd0 Reviewed-by: Marco Bubke <marco.bubke@qt.io>
2017-06-09 12:19:09 +02:00
ClangBackEnd::FileContainer ClangEditorDocumentProcessor::simpleFileContainer() const
{
Utf8String projectPartId;
if (m_projectPart)
projectPartId = m_projectPart->id();
return ClangBackEnd::FileContainer(filePath(), projectPartId, Utf8String(), false, revision());
}
Clang: Provide the language option to the backend Provide the language option (e.g. "-x c++-header") when registering a translation unit for the editor. Task-number: QTCREATORBUG-14787 Change-Id: Ie06f9fdab302f1b21ba72cdb65b6aabf9f7bc04c Reviewed-by: Erik Verbruggen <erik.verbruggen@theqtcompany.com>
2015-11-05 13:57:57 +01:00
static CppTools::ProjectPart projectPartForLanguageOption(CppTools::ProjectPart *projectPart)
{
if (projectPart)
return *projectPart;
return *CppTools::CppModelManager::instance()->fallbackProjectPart().data();
}
static QStringList languageOptions(const QString &filePath, CppTools::ProjectPart *projectPart)
{
CppTools: CompilerOptionsBuilder takes project part by reference ...since it assumes a project part != 0 and does not participate in ownership. Change-Id: Ia9c1eca52776990576a2dac61e9144234b04c59c Reviewed-by: Erik Verbruggen <erik.verbruggen@theqtcompany.com>
2015-11-05 11:47:01 +01:00
const auto theProjectPart = projectPartForLanguageOption(projectPart);
CppTools: Allow interpreting ambiguous headers as C headers ...instead of C++ headers. For the Clang Code Model this results in using "-x c-header" instead of "-x c++-header". This introduces a new option in Options > C++ > "Code Model" to configure this. Change-Id: I8a0ce8fa6155f5ef58743ebc7f1d0b500fbf6599 Reviewed-by: David Schulz <david.schulz@qt.io> Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io>
2017-01-12 18:01:12 +01:00
// Determine file kind with respect to ambiguous headers.
CppTools::ProjectFile::Kind fileKind = CppTools::ProjectFile::classify(filePath);
if (fileKind == CppTools::ProjectFile::AmbiguousHeader) {
fileKind = theProjectPart.languageVersion <= CppTools::ProjectPart::LatestCVersion
? CppTools::ProjectFile::CHeader
: CppTools::ProjectFile::CXXHeader;
}
Clang: Provide the language option to the backend Provide the language option (e.g. "-x c++-header") when registering a translation unit for the editor. Task-number: QTCREATORBUG-14787 Change-Id: Ie06f9fdab302f1b21ba72cdb65b6aabf9f7bc04c Reviewed-by: Erik Verbruggen <erik.verbruggen@theqtcompany.com>
2015-11-05 13:57:57 +01:00
CppTools::CompilerOptionsBuilder builder(theProjectPart);
CppTools: Allow interpreting ambiguous headers as C headers ...instead of C++ headers. For the Clang Code Model this results in using "-x c-header" instead of "-x c++-header". This introduces a new option in Options > C++ > "Code Model" to configure this. Change-Id: I8a0ce8fa6155f5ef58743ebc7f1d0b500fbf6599 Reviewed-by: David Schulz <david.schulz@qt.io> Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io>
2017-01-12 18:01:12 +01:00
builder.addLanguageOption(fileKind);
Clang: Provide the language option to the backend Provide the language option (e.g. "-x c++-header") when registering a translation unit for the editor. Task-number: QTCREATORBUG-14787 Change-Id: Ie06f9fdab302f1b21ba72cdb65b6aabf9f7bc04c Reviewed-by: Erik Verbruggen <erik.verbruggen@theqtcompany.com>
2015-11-05 13:57:57 +01:00
return builder.options();
}
Clang: Introduce warning configuration per project Change-Id: I5b9a330274e6f72b0786259eb25aa454877d4eef Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2016-02-26 17:50:38 +01:00
static QStringList warningOptions(CppTools::ProjectPart *projectPart)
{
if (projectPart && projectPart->project) {
ClangProjectSettings projectSettings(projectPart->project);
Clang: turn off delayed template parsing Fix templates highlight and completion on Windows Add UI to turn on/off delayed parsing (off by default) Task-number: QTCREATORBUG-17222 Change-Id: I0cd5e0bcfff2789cd938e4096829f777ff15957a Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-05-23 09:49:22 +02:00
if (!projectSettings.useGlobalConfig()) {
Clang: Introduce warning configuration per project Change-Id: I5b9a330274e6f72b0786259eb25aa454877d4eef Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2016-02-26 17:50:38 +01:00
const Core::Id warningConfigId = projectSettings.warningConfigId();
const CppTools::ClangDiagnosticConfigsModel configsModel(
CppTools::codeModelSettings()->clangCustomDiagnosticConfigs());
if (configsModel.hasConfigWithId(warningConfigId))
Clang: turn off delayed template parsing Fix templates highlight and completion on Windows Add UI to turn on/off delayed parsing (off by default) Task-number: QTCREATORBUG-17222 Change-Id: I0cd5e0bcfff2789cd938e4096829f777ff15957a Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-05-23 09:49:22 +02:00
return configsModel.configWithId(warningConfigId).commandLineWarnings();
Clang: Introduce warning configuration per project Change-Id: I5b9a330274e6f72b0786259eb25aa454877d4eef Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2016-02-26 17:50:38 +01:00
}
}
Clang: turn off delayed template parsing Fix templates highlight and completion on Windows Add UI to turn on/off delayed parsing (off by default) Task-number: QTCREATORBUG-17222 Change-Id: I0cd5e0bcfff2789cd938e4096829f777ff15957a Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-05-23 09:49:22 +02:00
return CppTools::codeModelSettings()->clangDiagnosticConfig().commandLineWarnings();
}
static QStringList commandLineOptions(CppTools::ProjectPart *projectPart)
{
if (!projectPart || !projectPart->project)
return ClangProjectSettings::globalCommandLineOptions();
return ClangProjectSettings{projectPart->project}.commandLineOptions();
Clang: Introduce warning configuration per project Change-Id: I5b9a330274e6f72b0786259eb25aa454877d4eef Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2016-02-26 17:50:38 +01:00
}
Clang: Take precompiled headers into account when parsing source files Task-number: QTCREATORBUG-15590 Change-Id: Icbfce4ffd6e9f9802641d35d898fa1dc1c4c18ee Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2016-11-02 12:21:54 +03:00
static QStringList precompiledHeaderOptions(
const QString& filePath,
CppTools::ProjectPart *projectPart)
{
using namespace CppTools;
if (CppTools::getPchUsage() == CompilerOptionsBuilder::PchUsage::None)
return QStringList();
if (projectPart->precompiledHeaders.contains(filePath))
return QStringList();
const CppTools::ProjectPart theProjectPart = projectPartForLanguageOption(projectPart);
CppTools::CompilerOptionsBuilder builder(theProjectPart);
builder.addPrecompiledHeaderOptions(CompilerOptionsBuilder::PchUsage::Use);
return builder.options();
}
Clang: Allow to provide extra command line options This can be used to experiment with clang options that e.g. affect diagnostics. Changes take effect on editor re-open. Change-Id: Ie46d0ff085a3700a748dbcf4b94b93b0bf9c4642 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Eike Ziller <eike.ziller@theqtcompany.com>
2015-11-10 16:54:53 +01:00
static QStringList fileArguments(const QString &filePath, CppTools::ProjectPart *projectPart)
{
Clang: Take precompiled headers into account when parsing source files Task-number: QTCREATORBUG-15590 Change-Id: Icbfce4ffd6e9f9802641d35d898fa1dc1c4c18ee Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2016-11-02 12:21:54 +03:00
return languageOptions(filePath, projectPart)
+ warningOptions(projectPart)
Clang: turn off delayed template parsing Fix templates highlight and completion on Windows Add UI to turn on/off delayed parsing (off by default) Task-number: QTCREATORBUG-17222 Change-Id: I0cd5e0bcfff2789cd938e4096829f777ff15957a Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-05-23 09:49:22 +02:00
+ commandLineOptions(projectPart)
Clang: Take precompiled headers into account when parsing source files Task-number: QTCREATORBUG-15590 Change-Id: Icbfce4ffd6e9f9802641d35d898fa1dc1c4c18ee Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2016-11-02 12:21:54 +03:00
+ precompiledHeaderOptions(filePath, projectPart);
Clang: Allow to provide extra command line options This can be used to experiment with clang options that e.g. affect diagnostics. Changes take effect on editor re-open. Change-Id: Ie46d0ff085a3700a748dbcf4b94b93b0bf9c4642 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Eike Ziller <eike.ziller@theqtcompany.com>
2015-11-10 16:54:53 +01:00
}
Clang: Add fileContainer getter File containers were generates in many places. To reduce the noise this getters are introduced. Change-Id: I059745c27ac2dd0515bc23b3438d6d264ba071d7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-10-05 11:17:03 +02:00
ClangBackEnd::FileContainer
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
ClangEditorDocumentProcessor::fileContainerWithArguments(CppTools::ProjectPart *projectPart) const
Clang: Add fileContainer getter File containers were generates in many places. To reduce the noise this getters are introduced. Change-Id: I059745c27ac2dd0515bc23b3438d6d264ba071d7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-10-05 11:17:03 +02:00
{
Clang: Provide the language option to the backend Provide the language option (e.g. "-x c++-header") when registering a translation unit for the editor. Task-number: QTCREATORBUG-14787 Change-Id: Ie06f9fdab302f1b21ba72cdb65b6aabf9f7bc04c Reviewed-by: Erik Verbruggen <erik.verbruggen@theqtcompany.com>
2015-11-05 13:57:57 +01:00
const auto projectPartId = projectPart
? Utf8String::fromString(projectPart->id())
: Utf8String();
Clang: Allow to provide extra command line options This can be used to experiment with clang options that e.g. affect diagnostics. Changes take effect on editor re-open. Change-Id: Ie46d0ff085a3700a748dbcf4b94b93b0bf9c4642 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Eike Ziller <eike.ziller@theqtcompany.com>
2015-11-10 16:54:53 +01:00
const QStringList theFileArguments = fileArguments(filePath(), projectPart);
Clang: Add fileContainer getter File containers were generates in many places. To reduce the noise this getters are introduced. Change-Id: I059745c27ac2dd0515bc23b3438d6d264ba071d7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-10-05 11:17:03 +02:00
Clang: Allow to provide extra command line options This can be used to experiment with clang options that e.g. affect diagnostics. Changes take effect on editor re-open. Change-Id: Ie46d0ff085a3700a748dbcf4b94b93b0bf9c4642 Reviewed-by: Leena Miettinen <riitta-leena.miettinen@theqtcompany.com> Reviewed-by: Eike Ziller <eike.ziller@theqtcompany.com>
2015-11-10 16:54:53 +01:00
return {filePath(), projectPartId, Utf8StringVector(theFileArguments), revision()};
Clang: Add fileContainer getter File containers were generates in many places. To reduce the noise this getters are introduced. Change-Id: I059745c27ac2dd0515bc23b3438d6d264ba071d7 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2015-10-05 11:17:03 +02:00
}
Clang: Fix initial document parse with modified content Reproduce with: 1. Create a new class named Foo with the wizard. 2. Close foo.h 3. In foo.cpp, add some class member function. 4. In foo.cpp, trigger the refactoring action "Add public Declaration" for the just defined member function. As a result, foo.h will be opened. ==> While the declaration was added, the header file is not yet reparsed with the new content - this can be verified by setting a custom color for "Function". In this use case, the refactoring action opens the editor and immediately modifies the document (RefactoringFile::apply). Fix by sending the document content along for the very first RegisterTranslationUnitForEditorMessage if the document was already modified. Change-Id: If20615a45b72dd0bef87e1870e403d0b277bc5d6 Reviewed-by: David Schulz <david.schulz@qt.io>
2016-11-22 15:17:42 +01:00
ClangBackEnd::FileContainer
ClangEditorDocumentProcessor::fileContainerWithArgumentsAndDocumentContent(
CppTools::ProjectPart *projectPart) const
{
const QStringList theFileArguments = fileArguments(filePath(), projectPart);
return ClangBackEnd::FileContainer(filePath(),
projectPart->id(),
Utf8StringVector(theFileArguments),
textDocument()->toPlainText(),
true,
revision());
}
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
ClangBackEnd::FileContainer
ClangEditorDocumentProcessor::fileContainerWithDocumentContent(const QString &projectpartId) const
{
return ClangBackEnd::FileContainer(filePath(),
projectpartId,
CppTools: Break TextDocument dependency of BaseEditorDocumentProcessor BaseEditorDocumentProcessor was holding a TextEditor::TextDocument but only used the QTextDocument and the file path. Change-Id: I349cc95d973adeaf9f94638d84333f592c14e7f9 Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>
2016-01-11 20:40:05 +01:00
textDocument()->toPlainText(),
Clang: Request diagnostics/highlighting only if needed Most of the time, the updated diagnostics/highlightings will be send by the backend on translation unit update. The other use case is changing the font settings (e.g. color), here we need to request the highlightings explicitly. Change-Id: I17a574eaf972c8bef12900241e7b33fe6ffd9dbd Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-11-30 10:55:25 +01:00
true,
revision());
}
Clang: Use completion through backend process This makes us independent of libclang crashes for completion. Re-parsing for highlighting still happens in the Qt Creator process. Run in verbose mode: qtc.clangcodemodel.ipc=true Run tests: -test "ClangCodeModel" Task-number: QTCREATORBUG-14108 Task-number: QTCREATORBUG-12819 Change-Id: Id3e95bd2afdb6508bbd1d35fddc69534a909b905 Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
2015-05-08 15:48:17 +02:00
} // namespace Internal
C++: Base parsing on editor document instead of widget This mainly takes CppEditorSupport apart. * Parsing is now invoked by CPPEditorDocument itself by listening to QTextDocument::contentsChanged(). * Upon construction and destruction CPPEditorDocument creates and deletes an EditorDocumentHandle for (un)registration in the model manager. This handle provides everything to generate the working copy and to access the editor document processor. * A CPPEditorDocument owns a BaseEditorDocumentProcessor instance that controls parsing, semantic info recalculation and the semantic highlighting for the document. This is more or less what is left from CppEditorSupport and can be considered as the backend of a CPPEditorDocument. CPPEditorDocument itself is quite small. * BuiltinEditorDocumentProcessor and ClangEditorDocumentProcessor derive from BaseEditorDocumentProcessor and implement the gaps. * Since the semantic info calculation was bound to the widget, it also calculated the local uses, which depend on the cursor position. This calculation got moved into the extracted class UseSeletionsUpdater in the cppeditor plugin, which is run once the cursor position changes or the semantic info document is updated. * Some more logic got extracted: - SemanticInfoUpdater (logic was in CppEditorSupport) - SemanticHighlighter (logic was in CppEditorSupport) * The *Parser and *Processor classes can be easily accessed by the static function get(). * CppHighlightingSupport is gone since it turned out to be useless. * The editor dependency in CompletionAssistProviders is gone since we actually only need the file path now. Change-Id: I49d3a7bd138c5ed9620123e34480772535156508 Reviewed-by: Orgad Shaneh <orgads@gmail.com> Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>
2014-08-19 15:59:29 +02:00
} // namespace ClangCodeModel
Copy Permalink