Commit de6d7f06 authored by Nikolai Kosjar's avatar Nikolai Kosjar

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: default avatarMarco Bubke <marco.bubke@theqtcompany.com>
parent c3772f47
......@@ -23,6 +23,8 @@ SOURCES += \
clangcompletionassistprocessor.cpp \
clangcompletionassistprovider.cpp \
clangcompletioncontextanalyzer.cpp \
clangdiagnosticfilter.cpp \
clangdiagnosticmanager.cpp \
clangeditordocumentparser.cpp \
clangeditordocumentprocessor.cpp \
clangfunctionhintmodel.cpp \
......@@ -61,6 +63,8 @@ HEADERS += \
clangcompletionassistprocessor.h \
clangcompletionassistprovider.h \
clangcompletioncontextanalyzer.h \
clangdiagnosticfilter.h \
clangdiagnosticmanager.h \
clangeditordocumentparser.h \
clangeditordocumentprocessor.h \
clangfunctionhintmodel.h \
......
......@@ -136,6 +136,10 @@ QtcPlugin {
"clangeditordocumentparser.h",
"clangeditordocumentprocessor.cpp",
"clangeditordocumentprocessor.h",
"clangdiagnosticfilter.cpp",
"clangdiagnosticfilter.h",
"clangdiagnosticmanager.cpp",
"clangdiagnosticmanager.h",
"clangmodelmanagersupport.cpp",
"clangmodelmanagersupport.h",
"clangcodemodelplugin.cpp",
......
......@@ -3,9 +3,12 @@ INCLUDEPATH += $$PWD
SOURCES += $$PWD/completionchunkstotextconverter.cpp \
$$PWD/activationsequenceprocessor.cpp \
$$PWD/activationsequencecontextprocessor.cpp \
$$PWD/clangcompletioncontextanalyzer.cpp
$$PWD/clangcompletioncontextanalyzer.cpp \
$$PWD/clangdiagnosticfilter.cpp
HEADERS += $$PWD/completionchunkstotextconverter.h \
$$PWD/activationsequenceprocessor.h \
$$PWD/activationsequencecontextprocessor.h \
$$PWD/clangcompletioncontextanalyzer.h
$$PWD/clangcompletioncontextanalyzer.h \
$$PWD/clangdiagnosticfilter.h
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "clangdiagnosticfilter.h"
namespace {
bool isWarningOrNote(ClangBackEnd::DiagnosticSeverity severity)
{
using ClangBackEnd::DiagnosticSeverity;
switch (severity) {
case DiagnosticSeverity::Ignored:
case DiagnosticSeverity::Note:
case DiagnosticSeverity::Warning: return true;
case DiagnosticSeverity::Error:
case DiagnosticSeverity::Fatal: return false;
}
Q_UNREACHABLE();
}
template <class Condition>
QVector<ClangBackEnd::DiagnosticContainer>
filterDiagnostics(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
const Condition &condition)
{
QVector<ClangBackEnd::DiagnosticContainer> filteredDiagnostics;
std::copy_if(diagnostics.cbegin(),
diagnostics.cend(),
std::back_inserter(filteredDiagnostics),
condition);
return filteredDiagnostics;
}
} // anonymous namespace
namespace ClangCodeModel {
namespace Internal {
void ClangDiagnosticFilter::filterDocumentRelatedWarnings(
const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics)
{
const auto isLocalWarning = [this] (const ClangBackEnd::DiagnosticContainer &diagnostic) {
return isWarningOrNote(diagnostic.severity())
&& diagnostic.location().filePath() == m_filePath;
};
m_warningDiagnostics = filterDiagnostics(diagnostics, isLocalWarning);
}
void ClangDiagnosticFilter::filterDocumentRelatedErrors(
const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics)
{
const auto isLocalWarning = [this] (const ClangBackEnd::DiagnosticContainer &diagnostic) {
return !isWarningOrNote(diagnostic.severity())
&& diagnostic.location().filePath() == m_filePath;
};
m_errorDiagnostics = filterDiagnostics(diagnostics, isLocalWarning);
}
ClangDiagnosticFilter::ClangDiagnosticFilter(const QString &filePath)
: m_filePath(filePath)
{
}
void ClangDiagnosticFilter::filter(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics)
{
filterDocumentRelatedWarnings(diagnostics);
filterDocumentRelatedErrors(diagnostics);
}
QVector<ClangBackEnd::DiagnosticContainer> ClangDiagnosticFilter::takeWarnings()
{
auto diagnostics = m_warningDiagnostics;
m_warningDiagnostics.clear();
return diagnostics;
}
QVector<ClangBackEnd::DiagnosticContainer> ClangDiagnosticFilter::takeErrors()
{
auto diagnostics = m_errorDiagnostics;
m_errorDiagnostics.clear();
return diagnostics;
}
} // namespace Internal
} // namespace ClangCodeModel
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef CLANGCODEMODEL_INTERNAL_CLANGDIAGNOSTICFILTER_H
#define CLANGCODEMODEL_INTERNAL_CLANGDIAGNOSTICFILTER_H
#include <clangbackendipc/diagnosticcontainer.h>
#include <QVector>
namespace ClangCodeModel {
namespace Internal {
class ClangDiagnosticFilter
{
public:
ClangDiagnosticFilter(const QString &filePath);
void filter(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics);
QVector<ClangBackEnd::DiagnosticContainer> takeWarnings();
QVector<ClangBackEnd::DiagnosticContainer> takeErrors();
private:
void filterDocumentRelatedWarnings(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics);
void filterDocumentRelatedErrors(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics);
private:
const QString &m_filePath;
QVector<ClangBackEnd::DiagnosticContainer> m_warningDiagnostics;
QVector<ClangBackEnd::DiagnosticContainer> m_errorDiagnostics;
};
} // namespace Internal
} // namespace ClangCodeModel
#endif // CLANGCODEMODEL_INTERNAL_CLANGDIAGNOSTICFILTER_H
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#include "clangdiagnosticfilter.h"
#include "clangdiagnosticmanager.h"
#include <texteditor/textdocument.h>
#include <utils/fileutils.h>
#include <utils/qtcassert.h>
namespace {
QTextEdit::ExtraSelection createExtraSelections(const QTextCharFormat &mainformat,
const QTextCursor &cursor,
const QString &diagnosticText)
{
QTextEdit::ExtraSelection extraSelection;
extraSelection.format = mainformat;
extraSelection.cursor = cursor;
extraSelection.format.setToolTip(diagnosticText);
return extraSelection;
}
void addRangeSelections(const ClangBackEnd::DiagnosticContainer &diagnostic,
QTextDocument *textDocument,
const QTextCharFormat &rangeFormat,
const QString &diagnosticText,
QList<QTextEdit::ExtraSelection> &extraSelections)
{
for (auto &&range : diagnostic.ranges()) {
QTextCursor cursor(textDocument);
cursor.setPosition(int(range.start().offset()));
cursor.setPosition(int(range.end().offset()), QTextCursor::KeepAnchor);
auto extraSelection = createExtraSelections(rangeFormat, cursor, diagnosticText);
extraSelections.push_back(std::move(extraSelection));
}
}
QTextCursor createSelectionCursor(QTextDocument *textDocument, uint position)
{
QTextCursor cursor(textDocument);
cursor.setPosition(int(position));
cursor.movePosition(QTextCursor::EndOfWord, QTextCursor::KeepAnchor);
if (!cursor.hasSelection()) {
cursor.setPosition(int(position) - 1);
cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor, 2);
}
return cursor;
}
bool isHelpfulChildDiagnostic(const ClangBackEnd::DiagnosticContainer &parentDiagnostic,
const ClangBackEnd::DiagnosticContainer &childDiagnostic)
{
auto parentLocation = parentDiagnostic.location();
auto childLocation = childDiagnostic.location();
return parentLocation == childLocation;
}
QString diagnosticText(const ClangBackEnd::DiagnosticContainer &diagnostic)
{
QString text = diagnostic.category().toString()
+ QStringLiteral(" ")
+ diagnostic.text().toString();
if (!diagnostic.enableOption().isEmpty()) {
text += QStringLiteral(" (clang option: ")
+ diagnostic.enableOption().toString()
+ QStringLiteral(" disable with: ")
+ diagnostic.disableOption().toString()
+ QStringLiteral(")");
}
for (auto &&childDiagnostic : diagnostic.children()) {
if (isHelpfulChildDiagnostic(diagnostic, childDiagnostic))
text += QStringLiteral("\n ") + childDiagnostic.text().toString();
}
return text;
}
void addSelections(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
QTextDocument *textDocument,
const QTextCharFormat &mainFormat,
const QTextCharFormat &rangeFormat,
QList<QTextEdit::ExtraSelection> &extraSelections)
{
for (auto &&diagnostic : diagnostics) {
auto cursor = createSelectionCursor(textDocument, diagnostic.location().offset());
auto text = diagnosticText(diagnostic);
auto extraSelection = createExtraSelections(mainFormat, cursor, text);
addRangeSelections(diagnostic, textDocument, rangeFormat, text, extraSelections);
extraSelections.push_back(std::move(extraSelection));
}
}
void addWarningSelections(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
QTextDocument *textDocument,
QList<QTextEdit::ExtraSelection> &extraSelections)
{
QTextCharFormat warningFormat;
warningFormat.setUnderlineStyle(QTextCharFormat::SingleUnderline);
warningFormat.setUnderlineColor(QColor(180, 180, 0, 255));
QTextCharFormat warningRangeFormat;
warningRangeFormat.setUnderlineStyle(QTextCharFormat::DotLine);
warningRangeFormat.setUnderlineColor(QColor(180, 180, 0, 255));
addSelections(diagnostics, textDocument, warningFormat, warningRangeFormat, extraSelections);
}
void addErrorSelections(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
QTextDocument *textDocument,
QList<QTextEdit::ExtraSelection> &extraSelections)
{
QTextCharFormat errorFormat;
errorFormat.setUnderlineStyle(QTextCharFormat::SingleUnderline);
errorFormat.setUnderlineColor(QColor(255, 0, 0, 255));
QTextCharFormat errorRangeFormat;
errorRangeFormat.setUnderlineStyle(QTextCharFormat::DotLine);
errorRangeFormat.setUnderlineColor(QColor(255, 0, 0, 255));
addSelections(diagnostics, textDocument, errorFormat, errorRangeFormat, extraSelections);
}
} // anonymous
namespace ClangCodeModel {
namespace Internal {
ClangDiagnosticManager::ClangDiagnosticManager(TextEditor::TextDocument *textDocument)
: m_textDocument(textDocument)
{
}
void ClangDiagnosticManager::generateTextMarks()
{
m_clangTextMarks.clear();
m_clangTextMarks.reserve(m_warningDiagnostics.size() + m_errorDiagnostics.size());
addClangTextMarks(m_warningDiagnostics);
addClangTextMarks(m_errorDiagnostics);
}
QList<QTextEdit::ExtraSelection> ClangDiagnosticManager::takeExtraSelections()
{
auto extraSelections = m_extraSelections;
m_extraSelections.clear();
return extraSelections;
}
void ClangDiagnosticManager::generateEditorSelections()
{
m_extraSelections.clear();
m_extraSelections.reserve(int(m_warningDiagnostics.size() + m_errorDiagnostics.size()));
addWarningSelections(m_warningDiagnostics, m_textDocument->document(), m_extraSelections);
addErrorSelections(m_errorDiagnostics, m_textDocument->document(), m_extraSelections);
}
void ClangDiagnosticManager::processNewDiagnostics(
const QVector<ClangBackEnd::DiagnosticContainer> &allDiagnostics)
{
filterDiagnostics(allDiagnostics);
generateTextMarks();
generateEditorSelections();
clearWarningsAndErrors();
}
void ClangDiagnosticManager::addClangTextMarks(
const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics)
{
QTC_ASSERT(m_clangTextMarks.size() + diagnostics.size() <= m_clangTextMarks.capacity(), return);
for (auto &&diagnostic : diagnostics) {
m_clangTextMarks.emplace_back(filePath(),
diagnostic.location().line(),
diagnostic.severity());
ClangTextMark &textMark = m_clangTextMarks.back();
textMark.setBaseTextDocument(m_textDocument);
m_textDocument->addMark(&textMark);
}
}
void ClangDiagnosticManager::clearWarningsAndErrors()
{
m_warningDiagnostics.clear();
m_errorDiagnostics.clear();
}
QString ClangDiagnosticManager::filePath() const
{
return m_textDocument->filePath().toString();
}
void ClangDiagnosticManager::filterDiagnostics(
const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics)
{
ClangDiagnosticFilter filter(filePath());
filter.filter(diagnostics);
m_warningDiagnostics = filter.takeWarnings();
m_errorDiagnostics = filter.takeErrors();
}
} // namespace Internal
} // namespace ClangCodeModel
/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms and
** conditions see http://www.qt.io/terms-conditions. For further information
** use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/
#ifndef CLANGCODEMODEL_INTERNAL_CLANGDIAGNOSTICMANAGER_H
#define CLANGCODEMODEL_INTERNAL_CLANGDIAGNOSTICMANAGER_H
#include "clangtextmark.h"
#include <clangbackendipc/diagnosticcontainer.h>
#include <QList>
#include <QTextEdit>
#include <QVector>
#include <vector>
namespace TextEditor { class TextDocument; }
namespace ClangCodeModel {
namespace Internal {
class ClangDiagnosticManager
{
public:
ClangDiagnosticManager(TextEditor::TextDocument *textDocument);
void processNewDiagnostics(const QVector<ClangBackEnd::DiagnosticContainer> &allDiagnostics);
QList<QTextEdit::ExtraSelection> takeExtraSelections();
private:
QString filePath() const;
void filterDiagnostics(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics);
void generateEditorSelections();
void generateTextMarks();
void addClangTextMarks(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics);
void clearWarningsAndErrors();
private:
TextEditor::TextDocument *m_textDocument;
QVector<ClangBackEnd::DiagnosticContainer> m_warningDiagnostics;
QVector<ClangBackEnd::DiagnosticContainer> m_errorDiagnostics;
QList<QTextEdit::ExtraSelection> m_extraSelections;
std::vector<ClangTextMark> m_clangTextMarks;
};
} // namespace Internal
} // namespace ClangCodeModel
#endif // CLANGCODEMODEL_INTERNAL_CLANGDIAGNOSTICMANAGER_H
......@@ -77,6 +77,7 @@ ClangEditorDocumentProcessor::ClangEditorDocumentProcessor(
ModelManagerSupportClang *modelManagerSupport,
TextEditor::TextDocument *document)
: BaseEditorDocumentProcessor(document)
, m_diagnosticManager(document)
, m_modelManagerSupport(modelManagerSupport)
, m_parser(new ClangEditorDocumentParser(document->filePath().toString()))
, m_parserRevision(0)
......@@ -179,7 +180,8 @@ void ClangEditorDocumentProcessor::updateCodeWarnings(const QVector<ClangBackEnd
uint documentRevision)
{
if (documentRevision == revision()) {
const auto codeWarnings = generateDiagnosticHints(diagnostics);
m_diagnosticManager.processNewDiagnostics(diagnostics);
const auto codeWarnings = m_diagnosticManager.takeExtraSelections();
emit codeWarningsUpdated(revision(), codeWarnings);
}
}
......@@ -246,219 +248,6 @@ void ClangEditorDocumentProcessor::updateTranslationUnitForEditor(CppTools::Proj
}
}
namespace {
bool isWarningOrNote(ClangBackEnd::DiagnosticSeverity severity)
{
using ClangBackEnd::DiagnosticSeverity;
switch (severity) {
case DiagnosticSeverity::Ignored:
case DiagnosticSeverity::Note:
case DiagnosticSeverity::Warning: return true;
case DiagnosticSeverity::Error:
case DiagnosticSeverity::Fatal: return false;
}
Q_UNREACHABLE();
}
bool isHelpfulChildDiagnostic(const ClangBackEnd::DiagnosticContainer &parentDiagnostic,
const ClangBackEnd::DiagnosticContainer &childDiagnostic)
{
auto parentLocation = parentDiagnostic.location();
auto childLocation = childDiagnostic.location();
return parentLocation == childLocation;
}
QString diagnosticText(const ClangBackEnd::DiagnosticContainer &diagnostic)
{
QString text = diagnostic.category().toString()
+ QStringLiteral(" ")
+ diagnostic.text().toString();
if (!diagnostic.enableOption().isEmpty()) {
text += QStringLiteral(" (clang option: ")
+ diagnostic.enableOption().toString()
+ QStringLiteral(" disable with: ")
+ diagnostic.disableOption().toString()
+ QStringLiteral(")");
}
for (auto &&childDiagnostic : diagnostic.children()) {
if (isHelpfulChildDiagnostic(diagnostic, childDiagnostic))
text += QStringLiteral("\n ") + childDiagnostic.text().toString();
}
return text;
}
template <class Condition>
std::vector<ClangBackEnd::DiagnosticContainer>
filterDiagnostics(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
const Condition &condition)
{
std::vector<ClangBackEnd::DiagnosticContainer> filteredDiagnostics;
std::copy_if(diagnostics.cbegin(),
diagnostics.cend(),
std::back_inserter(filteredDiagnostics),
condition);
return filteredDiagnostics;
}
std::vector<ClangBackEnd::DiagnosticContainer>
filterInterestingWarningDiagnostics(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
QString &&documentFilePath)
{
auto isLocalWarning = [documentFilePath] (const ClangBackEnd::DiagnosticContainer &diagnostic) {
return isWarningOrNote(diagnostic.severity())
&& diagnostic.location().filePath() == documentFilePath;
};
return filterDiagnostics(diagnostics, isLocalWarning);
}
std::vector<ClangBackEnd::DiagnosticContainer>
filterInterestingErrorsDiagnostics(const QVector<ClangBackEnd::DiagnosticContainer> &diagnostics,
QString &&documentFilePath)
{
auto isLocalWarning = [documentFilePath] (const ClangBackEnd::DiagnosticContainer &diagnostic) {