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>

src/plugins/clangcodemodel/clangcodemodel.pro

@@ -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 \

src/plugins/clangcodemodel/clangcodemodel.qbs

@@ -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",

src/plugins/clangcodemodel/clangcodemodelunittestfiles.pri

@@ -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

src/plugins/clangcodemodel/clangdiagnosticfilter.cpp

+/****************************************************************************
+**
+** 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
+

src/plugins/clangcodemodel/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.
+**
+****************************************************************************/
+
+#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

src/plugins/clangcodemodel/clangdiagnosticmanager.cpp

+/****************************************************************************
+**
+** 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

src/plugins/clangcodemodel/clangdiagnosticmanager.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.
+**
+****************************************************************************/
+
+#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

src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp

@@ -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) {