diff --git a/shell/problemmodel.cpp b/shell/problemmodel.cpp
index e0556d67dd..06f34e299c 100644
--- a/shell/problemmodel.cpp
+++ b/shell/problemmodel.cpp
@@ -1,340 +1,349 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "problemmodel.h"
 #include <QThread>
 #include <KLocalizedString>
 #include <interfaces/icore.h>
 #include <interfaces/idocument.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <interfaces/iassistant.h>
 #include <QIcon>
 #include <shell/problem.h>
 
 #include <shell/problemstore.h>
 #include <shell/problemstorenode.h>
 #include <shell/filteredproblemstore.h>
 #include <shell/problemconstants.h>
 #include <shell/watcheddocumentset.h>
 
 namespace {
 QIcon iconForSeverity(KDevelop::IProblem::Severity severity)
 {
     switch (severity) {
     case KDevelop::IProblem::Hint:
         return QIcon::fromTheme(QStringLiteral("dialog-information"));
     case KDevelop::IProblem::Warning:
         return QIcon::fromTheme(QStringLiteral("dialog-warning"));
     case KDevelop::IProblem::Error:
         return QIcon::fromTheme(QStringLiteral("dialog-error"));
     }
     return {};
 }
 
 }
 
 
 struct ProblemModelPrivate
 {
     ProblemModelPrivate(KDevelop::ProblemStore *store)
         : m_problems(store)
         , m_features(KDevelop::ProblemModel::NoFeatures)
     {
     }
 
     QScopedPointer<KDevelop::ProblemStore> m_problems;
     KDevelop::ProblemModel::Features m_features;
 };
 
 namespace KDevelop
 {
 
 ProblemModel::ProblemModel(QObject * parent, ProblemStore *store)
   : QAbstractItemModel(parent)
   , d(new ProblemModelPrivate(store))
 {
     if (!d->m_problems) {
         d->m_problems.reset(new FilteredProblemStore());
         d->m_features = ScopeFilter | SeverityFilter | Grouping | CanByPassScopeFilter;
     }
 
     setScope(CurrentDocument);
 
     connect(ICore::self()->documentController(), &IDocumentController::documentActivated, this, &ProblemModel::setCurrentDocument);
+    connect(ICore::self()->documentController(), &IDocumentController::documentClosed, this, &ProblemModel::closedDocument);
     /// CompletionSettings include a list of todo markers we care for, so need to update
     connect(ICore::self()->languageController()->completionSettings(), &ICompletionSettings::settingsChanged, this, &ProblemModel::forceFullUpdate);
 
     if (ICore::self()->documentController()->activeDocument()) {
         setCurrentDocument(ICore::self()->documentController()->activeDocument());
     }
 
     connect(d->m_problems.data(), &ProblemStore::beginRebuild, this, &ProblemModel::onBeginRebuild);
     connect(d->m_problems.data(), &ProblemStore::endRebuild, this, &ProblemModel::onEndRebuild);
 }
 
 ProblemModel::~ ProblemModel()
 {
 }
 
 int ProblemModel::rowCount(const QModelIndex& parent) const
 {
     if (!parent.isValid()) {
         return d->m_problems->count();
     } else {
         return d->m_problems->count(reinterpret_cast<ProblemStoreNode*>(parent.internalPointer()));
     }
 }
 
 static QString displayUrl(const QUrl &url, const QUrl &base)
 {
     if (base.isParentOf(url)) {
         return url.toDisplayString(QUrl::PreferLocalFile).mid(base.toDisplayString(QUrl::PreferLocalFile).length());
     } else {
         return ICore::self()->projectController()->prettyFileName(url, IProjectController::FormatPlain);
     }
 }
 
 QVariant ProblemModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid())
         return QVariant();
 
     QUrl baseDirectory = d->m_problems->currentDocument().toUrl().adjusted(QUrl::RemoveFilename);
     IProblem::Ptr p = problemForIndex(index);
     if (!p.constData()) {
         if (role == Qt::DisplayRole && index.column() == Error) {
             ProblemStoreNode *node = reinterpret_cast<ProblemStoreNode*>(index.internalPointer());
             if (node) {
                 return node->label();
             }
         }
         return {};
     }
 
     if (role == SeverityRole) {
         return p->severity();
     } else if (role == ProblemRole) {
         return QVariant::fromValue(p);
     }
 
     switch (role) {
     case Qt::DisplayRole:
         switch (index.column()) {
         case Source:
             return p->sourceString();
         case Error:
             return p->description();
         case File:
             return displayUrl(p->finalLocation().document.toUrl(), baseDirectory);
         case Line:
             if (p->finalLocation().isValid()) {
                 return QString::number(p->finalLocation().start().line() + 1);
             }
             break;
         case Column:
             if (p->finalLocation().isValid()) {
                 return QString::number(p->finalLocation().start().column() + 1);
             }
             break;
         }
         break;
 
     case Qt::DecorationRole:
         if (index.column() == Error) {
             return iconForSeverity(p->severity());
         }
         break;
     case Qt::ToolTipRole:
         return p->explanation();
 
     default:
         break;
     }
 
     return {};
 }
 
 QModelIndex ProblemModel::parent(const QModelIndex& index) const
 {
     ProblemStoreNode *node = reinterpret_cast<ProblemStoreNode*>(index.internalPointer());
     if (!node) {
         return {};
     }
 
     ProblemStoreNode *parent = node->parent();
     if (!parent || parent->isRoot()) {
         return {};
     }
 
     int idx = parent->index();
     return createIndex(idx, 0, parent);
 }
 
 QModelIndex ProblemModel::index(int row, int column, const QModelIndex& parent) const
 {
     if (row < 0 || row >= rowCount(parent) || column < 0 || column >= LastColumn) {
         return QModelIndex();
     }
 
     ProblemStoreNode *parentNode = reinterpret_cast<ProblemStoreNode*>(parent.internalPointer());
     const ProblemStoreNode *node = d->m_problems->findNode(row, parentNode);
     return createIndex(row, column, (void*)node);
 }
 
 int ProblemModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent)
     return LastColumn;
 }
 
 IProblem::Ptr ProblemModel::problemForIndex(const QModelIndex& index) const
 {
     ProblemStoreNode *node = reinterpret_cast<ProblemStoreNode*>(index.internalPointer());
     if (!node) {
         return {};
     } else {
         return node->problem();
     }
 }
 
 ProblemModel::Features ProblemModel::features() const
 {
     return d->m_features;
 }
 
 void ProblemModel::setFeatures(Features features)
 {
     d->m_features = features;
 }
 
 void ProblemModel::addProblem(const IProblem::Ptr &problem)
 {
     int c = d->m_problems->count();
     beginInsertRows(QModelIndex(), c, c + 1);
     d->m_problems->addProblem(problem);
     endInsertRows();
 }
 
 void ProblemModel::setProblems(const QVector<IProblem::Ptr> &problems)
 {
     beginResetModel();
     d->m_problems->setProblems(problems);
     endResetModel();
 }
 
 void ProblemModel::clearProblems()
 {
     beginResetModel();
     d->m_problems->clear();
     endResetModel();
 }
 
 
 QVariant ProblemModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(orientation);
 
     if (role != Qt::DisplayRole)
         return {};
 
     switch (section) {
         case Source:
             return i18nc("@title:column source of problem", "Source");
         case Error:
             return i18nc("@title:column problem description", "Problem");
         case File:
             return i18nc("@title:column file where problem was found", "File");
         case Line:
             return i18nc("@title:column line number with problem", "Line");
         case Column:
             return i18nc("@title:column column number with problem", "Column");
     }
 
     return {};
 }
 
 void ProblemModel::setCurrentDocument(IDocument* document)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     QUrl currentDocument = document->url();
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setCurrentDocument(IndexedString(currentDocument));
 }
 
+void ProblemModel::closedDocument(IDocument* document)
+{
+    if (IndexedString(document->url()) == d->m_problems->currentDocument())
+    {   // reset current document
+        d->m_problems->setCurrentDocument(IndexedString());
+    }
+}
+
 void ProblemModel::onBeginRebuild()
 {
     beginResetModel();
 }
 
 void ProblemModel::onEndRebuild()
 {
     endResetModel();
 }
 
 void ProblemModel::setScope(int scope)
 {
     Q_ASSERT(thread() == QThread::currentThread());
 
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setScope(scope);
 }
 
 void ProblemModel::setSeverity(int severity)
 {
     switch (severity)
     {
         case KDevelop::IProblem::Error:
             setSeverities(KDevelop::IProblem::Error);
             break;
         case KDevelop::IProblem::Warning:
             setSeverities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning);
             break;
         case KDevelop::IProblem::Hint:
             setSeverities(KDevelop::IProblem::Error | KDevelop::IProblem::Warning | KDevelop::IProblem::Hint);
             break;
     }
 }
 
 void ProblemModel::setSeverities(KDevelop::IProblem::Severities severities)
 {
     Q_ASSERT(thread() == QThread::currentThread());
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setSeverities(severities);
 }
 
 void ProblemModel::setGrouping(int grouping)
 {
     /// Will trigger signals beginRebuild(), endRebuild() if problems change and are rebuilt
     d->m_problems->setGrouping(grouping);
 }
 
 ProblemStore* ProblemModel::store() const
 {
     return d->m_problems.data();
 }
 
 }
 
 
diff --git a/shell/problemmodel.h b/shell/problemmodel.h
index 89c844874e..be962be9bc 100644
--- a/shell/problemmodel.h
+++ b/shell/problemmodel.h
@@ -1,184 +1,186 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2007 Hamish Rodda <rodda@kde.org>
  * Copyright 2015 Laszlo Kis-Adam <laszlo.kis-adam@kdemail.net>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU Library General Public License as
  * published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public
  * License along with this program; if not, write to the
  * Free Software Foundation, Inc.,
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #ifndef PROBLEMMODEL_H
 #define PROBLEMMODEL_H
 
 #include <shell/shellexport.h>
 #include <QtCore/QAbstractItemModel>
 #include <shell/problem.h>
 #include <QUrl>
 
 struct ProblemModelPrivate;
 
 namespace KDevelop {
     class IDocument;
 
 class ProblemStore;
 
 /**
  * @brief Wraps a ProblemStore and adds the QAbstractItemModel interface, so the it can be used in a model/view architecture.
  *
  * By default ProblemModel instantiates a FilteredProblemStore, with the following features on:
  * \li ScopeFilter
  * \li SeverityFilter
  * \li Grouping
  * \li CanByPassScopeFilter
  *
  * Has to following columns:
  * \li Error
  * \li Source
  * \li File
  * \li Line
  * \li Column
  * \li LastColumn
  *
  * Possible ProblemModel features
  * \li NoFeatures
  * \li CanDoFullUpdate
  * \li CanShowImports
  * \li ScopeFilter
  * \li SeverityFilter
  * \li Grouping
  * \li CanByPassScopeFilter
  *
  * Scope, severity, grouping, imports can be set using the slots named after these features.
  *
  * Usage example:
  * @code
  * IProblem::Ptr problem(new DetectedProblem);
  * problem->setDescription(QStringLiteral("Problem"));
  * ProblemModel *model = new ProblemModel(nullptr);
  * model->addProblem(problem);
  * model->rowCount(); // returns 1
  * QModelIndex idx = model->index(0, 0);
  * model->data(index); // "Problem"
  * @endcode
  *
  */
 class KDEVPLATFORMSHELL_EXPORT ProblemModel : public QAbstractItemModel
 {
     Q_OBJECT
 
 public:
     /// List of supportable features
     enum FeatureCode
     {
         NoFeatures                 = 0,  /// No features :(
         CanDoFullUpdate            = 1,  /// Reload/Reparse problems
         CanShowImports             = 2,  /// Show problems from imported files. E.g.: Header files in C/C++
         ScopeFilter                = 4,  /// Filter problems by scope. E.g.: current document, open documents, etc
         SeverityFilter             = 8,  /// Filter problems by severity. E.g.: hint, warning, error, etc
         Grouping                   = 16, /// Can group problems
         CanByPassScopeFilter       = 32  /// Can bypass scope filter
     };
 
     Q_DECLARE_FLAGS(Features, FeatureCode)
 
     explicit ProblemModel(QObject *parent, ProblemStore *store = NULL);
     ~ProblemModel() override;
 
     enum Columns {
         Error,
         Source,
         File,
         Line,
         Column,
         LastColumn
     };
 
     enum Roles {
         ProblemRole = Qt::UserRole + 1,
         SeverityRole
     };
 
     int columnCount(const QModelIndex & parent = QModelIndex()) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const override;
     QModelIndex parent(const QModelIndex & index) const override;
     QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
     int rowCount(const QModelIndex & parent = QModelIndex()) const override;
     QVariant headerData ( int section, Qt::Orientation orientation, int role = Qt::DisplayRole ) const override;
 
     IProblem::Ptr problemForIndex(const QModelIndex& index) const;
 
     /// Adds a new problem to the model
     void addProblem(const IProblem::Ptr &problem);
 
     /// Clears the problems, then adds a new set of them
     void setProblems(const QVector<IProblem::Ptr> &problems);
 
     /// Clears the problems
     void clearProblems();
 
     /// Retrieve the supported features
     Features features() const;
 
     /// Set the supported features
     void setFeatures(Features features);
 
 public slots:
     /// Show imports
     virtual void setShowImports(bool){}
 
     /// Sets the scope filter. Uses int to be able to use QSignalMapper
     virtual void setScope(int scope);
 
     /// Sets the severity filter. Uses int to be able to use QSignalMapper
     virtual void setSeverity(int severity);///old-style severity filtering
 
     virtual void setSeverities(KDevelop::IProblem::Severities severities);///new-style severity filtering
 
     void setGrouping(int grouping);
 
     /**
      * Force a full problem update.
      * E.g.: Reparse the source code.
      * Obviously it doesn't make sense for run-time problem checkers.
      */
     virtual void forceFullUpdate(){}
 
 protected slots:
     /// Triggered when problems change
     virtual void onProblemsChanged(){}
 
 private slots:
     /// Triggered when the current document changes
     virtual void setCurrentDocument(IDocument* doc);
 
+    virtual void closedDocument(IDocument* doc);
+
     /// Triggered before the problems are rebuilt
     void onBeginRebuild();
 
     /// Triggered once the problems have been rebuilt
     void onEndRebuild();
 
 protected:
     ProblemStore *store() const;
 
 private:
     QScopedPointer<ProblemModelPrivate> d;
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(ProblemModel::Features)
 
 }
 
 #endif // PROBLEMMODEL_H