diff --git a/plugins/filetemplates/filetemplatesplugin.cpp b/plugins/filetemplates/filetemplatesplugin.cpp
index 598a236e4..95de03b0d 100644
--- a/plugins/filetemplates/filetemplatesplugin.cpp
+++ b/plugins/filetemplates/filetemplatesplugin.cpp
@@ -1,288 +1,317 @@
 #include "filetemplatesplugin.h"
 #include "templateclassassistant.h"
 #include "templatepreviewtoolview.h"
 #include "debug.h"
 
 #include <language/codegen/templatesmodel.h>
 #include <language/interfaces/editorcontext.h>
 #include <interfaces/icore.h>
+#include <interfaces/iproject.h>
 #include <interfaces/iuicontroller.h>
 #include <interfaces/context.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/idocumentcontroller.h>
+#include <interfaces/iselectioncontroller.h>
+#include <interfaces/iprojectcontroller.h>
 #include <project/projectmodel.h>
 #include <util/path.h>
 
 #include <KActionCollection>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include <QAction>
 #include <QApplication>
 #include <QDir>
 #include <QIcon>
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(FileTemplatesFactory, "kdevfiletemplates.json", registerPlugin<FileTemplatesPlugin>();)
 
 class TemplatePreviewFactory : public KDevelop::IToolViewFactory
 {
 public:
     TemplatePreviewFactory(FileTemplatesPlugin* plugin)
     : KDevelop::IToolViewFactory()
     , m_plugin(plugin)
     {
 
     }
 
     QWidget* create(QWidget* parent = nullptr) override
     {
         return new TemplatePreviewToolView(m_plugin, parent);
     }
 
     QString id() const override
     {
         return QStringLiteral("org.kdevelop.TemplateFilePreview");
     }
 
     Qt::DockWidgetArea defaultPosition() override
     {
         return Qt::RightDockWidgetArea;
     }
 
 private:
     FileTemplatesPlugin* m_plugin;
 };
 
 FileTemplatesPlugin::FileTemplatesPlugin(QObject* parent, const QVariantList& args)
     : IPlugin(QStringLiteral("kdevfiletemplates"), parent)
     , m_model(nullptr)
 {
     Q_UNUSED(args);
 
     setXMLFile(QStringLiteral("kdevfiletemplates.rc"));
     QAction* action = actionCollection()->addAction(QStringLiteral("new_from_template"));
     action->setText( i18n( "New From Template" ) );
     action->setIcon( QIcon::fromTheme( QStringLiteral("code-class") ) );
     action->setWhatsThis( i18n( "Allows you to create new source code files, such as classes or unit tests, using templates." ) );
     action->setStatusTip( i18n( "Create new files from a template" ) );
     connect (action, &QAction::triggered, this, &FileTemplatesPlugin::createFromTemplate);
 
     m_toolView = new TemplatePreviewFactory(this);
     core()->uiController()->addToolView(i18n("Template Preview"), m_toolView);
 }
 
 FileTemplatesPlugin::~FileTemplatesPlugin()
 {
 
 }
 
 void FileTemplatesPlugin::unload()
 {
     core()->uiController()->removeToolView(m_toolView);
 }
 
 ContextMenuExtension FileTemplatesPlugin::contextMenuExtension (Context* context)
 {
     ContextMenuExtension ext;
     QUrl fileUrl;
 
     if (context->type() == Context::ProjectItemContext)
     {
         ProjectItemContext* projectContext = dynamic_cast<ProjectItemContext*>(context);
         QList<ProjectBaseItem*> items = projectContext->items();
         if (items.size() != 1)
         {
             return ext;
         }
 
         QUrl url;
         ProjectBaseItem* item = items.first();
         if (item->folder())
         {
             url = item->path().toUrl();
         }
         else if (item->target())
         {
             url = item->parent()->path().toUrl();
         }
         if (url.isValid())
         {
             QAction* action = new QAction(i18n("Create From Template"), this);
             action->setIcon(QIcon::fromTheme(QStringLiteral("code-class")));
             action->setData(url);
             connect(action, &QAction::triggered, this, &FileTemplatesPlugin::createFromTemplate);
             ext.addAction(ContextMenuExtension::FileGroup, action);
         }
 
         if (item->file())
         {
             fileUrl = item->path().toUrl();
         }
     }
     else if (context->type() == Context::EditorContext)
     {
         KDevelop::EditorContext* editorContext = dynamic_cast<KDevelop::EditorContext*>(context);
         fileUrl = editorContext->url();
     }
 
     if (fileUrl.isValid() && determineTemplateType(fileUrl) != NoTemplate)
     {
         QAction* action = new QAction(i18n("Show Template Preview"), this);
         action->setIcon(QIcon::fromTheme(QStringLiteral("document-preview")));
         action->setData(fileUrl);
         connect(action, &QAction::triggered, this, &FileTemplatesPlugin::previewTemplate);
         ext.addAction(ContextMenuExtension::ExtensionGroup, action);
     }
 
     return ext;
 }
 
 QString FileTemplatesPlugin::name() const
 {
     return i18n("File Templates");
 }
 
 QIcon FileTemplatesPlugin::icon() const
 {
     return QIcon::fromTheme(QStringLiteral("code-class"));
 }
 
 QAbstractItemModel* FileTemplatesPlugin::templatesModel()
 {
     if(!m_model) {
         m_model = new TemplatesModel(QStringLiteral("kdevfiletemplates"), this);
     }
     return m_model;
 }
 
 QString FileTemplatesPlugin::knsConfigurationFile() const
 {
     return QStringLiteral("kdevfiletemplates.knsrc");
 }
 
 QStringList FileTemplatesPlugin::supportedMimeTypes() const
 {
     QStringList types;
     types << QStringLiteral("application/x-desktop");
     types << QStringLiteral("application/x-bzip-compressed-tar");
     types << QStringLiteral("application/zip");
     return types;
 }
 
 void FileTemplatesPlugin::reload()
 {
     templatesModel();
     m_model->refresh();
 }
 
 void FileTemplatesPlugin::loadTemplate(const QString& fileName)
 {
     templatesModel();
     m_model->loadTemplateFile(fileName);
 }
 
 void FileTemplatesPlugin::createFromTemplate()
 {
     QUrl baseUrl;
     if (QAction* action = qobject_cast<QAction*>(sender()))
     {
         baseUrl = action->data().toUrl();
     }
     if (!baseUrl.isValid()) {
         // fall-back to currently active document's parent directory
         IDocument* doc = ICore::self()->documentController()->activeDocument();
         if (doc && doc->url().isValid()) {
             baseUrl = doc->url().adjusted(QUrl::RemoveFilename);
         }
     }
+    if (!baseUrl.isValid()) {
+        // fall-back to currently selected project's or item's base directory
+        ProjectItemContext* projectContext = dynamic_cast<ProjectItemContext*>(ICore::self()->selectionController()->currentSelection());
+        if (projectContext) {
+            const QList<ProjectBaseItem*> items = projectContext->items();
+            if (items.size() == 1) {
+                ProjectBaseItem* item = items.at(0);
+                if (item->folder()) {
+                    baseUrl = item->path().toUrl();
+                } else if (item->target()) {
+                    baseUrl = item->parent()->path().toUrl();
+                }
+            }
+        }
+    }
+    if (!baseUrl.isValid()) {
+        // fall back to base directory of currently open project, if there is only one
+        const QList<IProject*> projects = ICore::self()->projectController()->projects();
+        if (projects.size() == 1) {
+            baseUrl = projects.at(0)->path().toUrl();
+        }
+    }
+    if (!baseUrl.isValid()) {
+        // last resort: home path
+        baseUrl = QUrl::fromLocalFile(QDir::homePath());
+    }
     TemplateClassAssistant* assistant = new TemplateClassAssistant(QApplication::activeWindow(), baseUrl);
     assistant->setAttribute(Qt::WA_DeleteOnClose);
     assistant->show();
 }
 
 FileTemplatesPlugin::TemplateType FileTemplatesPlugin::determineTemplateType(const QUrl& url)
 {
     QDir dir(url.toLocalFile());
 
     /*
      * Search for a description file in the url's directory.
      * If it is not found there, try cascading up a maximum of 5 directories.
      */
     int level = 0;
     while (dir.cdUp() && level < 5)
     {
         QStringList filters;
         filters << QStringLiteral("*.kdevtemplate") << QStringLiteral("*.desktop");
         foreach (const QString& entry, dir.entryList(filters))
         {
             qCDebug(PLUGIN_FILETEMPLATES) << "Trying entry" << entry;
             /*
             * This logic is not perfect, but it works for most cases.
             *
             * Project template description files usually have the suffix
             * ".kdevtemplate", so those are easy to find. For project templates,
             * all the files in the directory are template files.
             *
             * On the other hand, file templates use the generic suffix ".desktop".
             * Fortunately, those explicitly list input and output files, so we
             * only match the explicitly listed files
             */
             if (entry.endsWith(QLatin1String(".kdevtemplate")))
             {
                 return ProjectTemplate;
             }
 
             KConfig* config = new KConfig(dir.absoluteFilePath(entry), KConfig::SimpleConfig);
             KConfigGroup group = config->group("General");
 
             qCDebug(PLUGIN_FILETEMPLATES) << "General group keys:" << group.keyList();
 
             if (!group.hasKey("Name") || !group.hasKey("Category"))
             {
                 continue;
             }
 
             if (group.hasKey("Files"))
             {
                 qCDebug(PLUGIN_FILETEMPLATES) << "Group has files " << group.readEntry("Files", QStringList());
                 foreach (const QString& outputFile, group.readEntry("Files", QStringList()))
                 {
                     if (dir.absoluteFilePath(config->group(outputFile).readEntry("File")) == url.toLocalFile())
                     {
                         return FileTemplate;
                     }
                 }
             }
 
             if (group.hasKey("ShowFilesAfterGeneration"))
             {
                 return ProjectTemplate;
             }
         }
 
         ++level;
     }
 
     return NoTemplate;
 }
 
 void FileTemplatesPlugin::previewTemplate()
 {
     QAction* action = qobject_cast<QAction*>(sender());
     if (!action || !action->data().toUrl().isValid())
     {
         return;
     }
     TemplatePreviewToolView* preview = qobject_cast<TemplatePreviewToolView*>(core()->uiController()->findToolView(i18n("Template Preview"), m_toolView));
     if (!preview)
     {
         return;
     }
 
     core()->documentController()->activateDocument(core()->documentController()->openDocument(action->data().toUrl()));
 }
 
 #include "filetemplatesplugin.moc"
diff --git a/plugins/problemreporter/problemhighlighter.cpp b/plugins/problemreporter/problemhighlighter.cpp
index 92ae52a2c..cce7d0822 100644
--- a/plugins/problemreporter/problemhighlighter.cpp
+++ b/plugins/problemreporter/problemhighlighter.cpp
@@ -1,231 +1,227 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2008 Hamish Rodda <rodda@kde.org>
  * Copyright 2008-2009 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * 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 "problemhighlighter.h"
 
 #include <KTextEditor/Document>
 #include <KTextEditor/MarkInterface>
 #include <ktexteditor/view.h>
 #include <ktexteditor/movinginterface.h>
 
 #include <serialization/indexedstring.h>
 #include <language/duchain/navigation/abstractnavigationwidget.h>
 #include <language/util/navigationtooltip.h>
 #include <interfaces/icore.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icompletionsettings.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/navigation/problemnavigationcontext.h>
 #include <util/texteditorhelpers.h>
 
 #include <kcolorscheme.h>
 
 #include <shell/problem.h>
 
 using namespace KTextEditor;
 using namespace KDevelop;
 
 namespace
 {
 
 QColor colorForSeverity(IProblem::Severity severity)
 {
     KColorScheme scheme(QPalette::Active);
     switch (severity) {
     case IProblem::Error:
         return scheme.foreground(KColorScheme::NegativeText).color();
     case IProblem::Warning:
         return scheme.foreground(KColorScheme::NeutralText).color();
     case IProblem::Hint:
     default:
         return scheme.foreground(KColorScheme::PositiveText).color();
     }
 }
 }
 
 ProblemHighlighter::ProblemHighlighter(KTextEditor::Document* document)
     : m_document(document)
 {
     Q_ASSERT(m_document);
 
     connect(ICore::self()->languageController()->completionSettings(), &ICompletionSettings::settingsChanged, this,
             &ProblemHighlighter::settingsChanged);
     connect(m_document.data(), &Document::aboutToReload, this, &ProblemHighlighter::clearProblems);
     if (qobject_cast<MovingInterface*>(m_document)) {
         // can't use new signal/slot syntax here, MovingInterface is not a QObject
         connect(m_document, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)), this,
                 SLOT(clearProblems()));
     }
     connect(m_document, SIGNAL(aboutToRemoveText(KTextEditor::Range)), this,
             SLOT(aboutToRemoveText(KTextEditor::Range)));
 }
 
 void ProblemHighlighter::settingsChanged()
 {
     // Re-highlight
     setProblems(m_problems);
 }
 
 ProblemHighlighter::~ProblemHighlighter()
 {
     if (m_topHLRanges.isEmpty() || !m_document)
         return;
 
     qDeleteAll(m_topHLRanges);
 }
 
 void ProblemHighlighter::setProblems(const QVector<IProblem::Ptr>& problems)
 {
     if (!m_document)
         return;
 
     if (m_problems == problems)
         return;
 
     const bool hadProblems = !m_problems.isEmpty();
     m_problems = problems;
 
     qDeleteAll(m_topHLRanges);
     m_topHLRanges.clear();
-    m_problemsForRanges.clear();
 
     IndexedString url(m_document->url());
 
     /// TODO: create a better MarkInterface that makes it possible to add the marks to the scrollbar
     ///      but having no background.
     ///      also make it nicer together with other plugins, this would currently fail with
     ///      this method...
     const uint errorMarkType = KTextEditor::MarkInterface::Error;
     const uint warningMarkType = KTextEditor::MarkInterface::Warning;
     KTextEditor::MarkInterface* markIface = dynamic_cast<KTextEditor::MarkInterface*>(m_document.data());
     if (markIface && hadProblems) {
         // clear previously added marks
         foreach (KTextEditor::Mark* mark, markIface->marks()) {
             if (mark->type == errorMarkType || mark->type == warningMarkType) {
                 markIface->removeMark(mark->line, mark->type);
             }
         }
     }
 
     if (problems.isEmpty()) {
         return;
     }
 
     DUChainReadLocker lock;
 
     TopDUContext* top = DUChainUtils::standardContextForUrl(m_document->url());
 
     KTextEditor::MovingInterface* iface = dynamic_cast<KTextEditor::MovingInterface*>(m_document.data());
     Q_ASSERT(iface);
 
     foreach (const IProblem::Ptr& problem, problems) {
         if (problem->finalLocation().document != url || !problem->finalLocation().isValid())
             continue;
 
         KTextEditor::Range range;
         if (top)
             range = top->transformFromLocalRevision(RangeInRevision::castFromSimpleRange(problem->finalLocation()));
         else
             range = problem->finalLocation();
 
         // Fix problem's location range if necessary
         if (problem->finalLocationMode() != IProblem::Range && range.onSingleLine()) {
             int line = range.start().line();
             const QString lineString = m_document->line(line);
 
             int startColumn = 0;
             int endColumn = lineString.length() - 1;
 
             if (problem->finalLocationMode() == IProblem::TrimmedLine) {
                 while (lineString.at(startColumn++).isSpace()) {}
                 --startColumn;
 
                 while (lineString.at(endColumn--).isSpace()) {}
                 ++endColumn;
             }
 
             range.setStart(Cursor(line, startColumn));
             range.setEnd(Cursor(line, endColumn));
 
             problem->setFinalLocation(DocumentRange(problem->finalLocation().document, range));
             problem->setFinalLocationMode(IProblem::Range);
         }
 
         if (range.end().line() >= m_document->lines())
             range.end() = KTextEditor::Cursor(m_document->endOfLine(m_document->lines() - 1));
 
         if (range.isEmpty()) {
             range.setEnd(range.end() + KTextEditor::Cursor(0, 1));
         }
 
         KTextEditor::MovingRange* problemRange = iface->newMovingRange(range);
-
-        m_problemsForRanges.insert(problemRange, problem);
         m_topHLRanges.append(problemRange);
 
         if (problem->source() != IProblem::ToDo
             && (problem->severity() != IProblem::Hint
                 || ICore::self()->languageController()->completionSettings()->highlightSemanticProblems())) {
             KTextEditor::Attribute::Ptr attribute(new KTextEditor::Attribute());
             attribute->setUnderlineStyle(QTextCharFormat::WaveUnderline);
             attribute->setUnderlineColor(colorForSeverity(problem->severity()));
             problemRange->setAttribute(attribute);
         }
 
         if (markIface && ICore::self()->languageController()->completionSettings()->highlightProblematicLines()) {
             uint mark;
             if (problem->severity() == IProblem::Error) {
                 mark = errorMarkType;
             } else if (problem->severity() == IProblem::Warning) {
                 mark = warningMarkType;
             } else {
                 continue;
             }
             markIface->addMark(problem->finalLocation().start().line(), mark);
         }
     }
 }
 
 void ProblemHighlighter::aboutToRemoveText(const KTextEditor::Range& range)
 {
     if (range.onSingleLine()) { // no need to optimize this
         return;
     }
 
     QList<MovingRange*>::iterator it = m_topHLRanges.begin();
     while (it != m_topHLRanges.end()) {
         if (range.contains((*it)->toRange())) {
-            m_problemsForRanges.remove(*it);
             delete (*it);
             it = m_topHLRanges.erase(it);
         } else {
             ++it;
         }
     }
 }
 
 void ProblemHighlighter::clearProblems()
 {
     setProblems({});
 }
diff --git a/plugins/problemreporter/problemhighlighter.h b/plugins/problemreporter/problemhighlighter.h
index 6026818b6..97dde7a2e 100644
--- a/plugins/problemreporter/problemhighlighter.h
+++ b/plugins/problemreporter/problemhighlighter.h
@@ -1,54 +1,53 @@
 /*
  * KDevelop Problem Reporter
  *
  * Copyright 2008 Hamish Rodda <rodda@kde.org>
  * Copyright 2008-2009 David Nolden <david.nolden.kdevelop@art-master.de>
  *
  * 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 KDEVPLATFORM_PLUGIN_PROBLEM_HIGHLIGHT_H
 #define KDEVPLATFORM_PLUGIN_PROBLEM_HIGHLIGHT_H
 
 #include <language/duchain/problem.h>
 #include <qpointer.h>
 #include <ktexteditor/movingrange.h>
 #include <interfaces/iproblem.h>
 
 class ProblemHighlighter : public QObject
 {
     Q_OBJECT
 public:
     explicit ProblemHighlighter(KTextEditor::Document* document);
     ~ProblemHighlighter() override;
 
     void setProblems(const QVector<KDevelop::IProblem::Ptr>& problems);
 
 private slots:
     void aboutToRemoveText(const KTextEditor::Range& range);
     void clearProblems();
 
 private:
     QPointer<KTextEditor::Document> m_document;
     QList<KTextEditor::MovingRange*> m_topHLRanges;
     QVector<KDevelop::IProblem::Ptr> m_problems;
-    QMap<KTextEditor::MovingRange*, KDevelop::IProblem::Ptr> m_problemsForRanges;
 
 public slots:
     void settingsChanged();
 };
 
 #endif // KDEVPLATFORM_PLUGIN_PROBLEM_HIGHLIGHT_H