diff --git a/debugger/CMakeLists.txt b/debugger/CMakeLists.txt
index a656645a3..ba8ab8cff 100644
--- a/debugger/CMakeLists.txt
+++ b/debugger/CMakeLists.txt
@@ -1,63 +1,64 @@
 add_definitions(-DTRANSLATION_DOMAIN=\"kdevplatform\")
 
 set(KDevPlatformDebugger_LIB_SRCS
     interfaces/idebugsession.cpp
     interfaces/iframestackmodel.cpp
     interfaces/ibreakpointcontroller.cpp
     interfaces/ivariablecontroller.cpp
     util/treeitem.cpp
     util/treemodel.cpp
     util/treeview.cpp
     util/pathmappings.cpp
     util/debug.cpp
     breakpoint/breakpoint.cpp
     breakpoint/breakpointmodel.cpp
     breakpoint/breakpointwidget.cpp
     breakpoint/breakpointdetails.cpp
     variable/variablewidget.cpp
     variable/variablecollection.cpp
     variable/variabletooltip.cpp
+    variable/variablesortmodel.cpp
     framestack/framestackmodel.cpp
     framestack/framestackwidget.cpp
 )
 kdevplatform_add_library(KDevPlatformDebugger SOURCES ${KDevPlatformDebugger_LIB_SRCS})
 target_link_libraries(KDevPlatformDebugger
 LINK_PUBLIC
     KDev::Interfaces
     KDev::Util
 LINK_PRIVATE
     Qt5::Core
     KF5::Notifications
     KF5::TextEditor
     KDev::Sublime
 )
 
 install(FILES
     interfaces/idebugsession.h
     interfaces/ibreakpointcontroller.h
     interfaces/ivariablecontroller.h
     interfaces/iframestackmodel.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/kdevplatform/debugger/interfaces COMPONENT Devel
 )
 install(FILES
     util/treemodel.h
     util/treeitem.h
     util/treeview.h
     util/pathmappings.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/kdevplatform/debugger/util COMPONENT Devel
 )
 install(FILES
     breakpoint/breakpointwidget.h
     breakpoint/breakpointdetails.h
     breakpoint/breakpoint.h
     breakpoint/breakpointmodel.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/kdevplatform/debugger/breakpoint COMPONENT Devel
 )
 install(FILES
     variable/variablecollection.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/kdevplatform/debugger/variable COMPONENT Devel
 )
 install(FILES
     framestack/framestackmodel.h
     DESTINATION ${KDE_INSTALL_INCLUDEDIR}/kdevplatform/debugger/framestack COMPONENT Devel
 )
diff --git a/debugger/variable/variablesortmodel.cpp b/debugger/variable/variablesortmodel.cpp
new file mode 100644
index 000000000..a949bd3e8
--- /dev/null
+++ b/debugger/variable/variablesortmodel.cpp
@@ -0,0 +1,46 @@
+/*
+ * KDevelop Debugger Support
+ *
+ * Copyright 2016 Mikhail Ivchenko <ematirov@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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 "variablesortmodel.h"
+
+#include <QSortFilterProxyModel>
+#include <QCollator>
+
+namespace KDevelop
+{
+
+VariableSortProxyModel::VariableSortProxyModel(QObject *parent)
+    : QSortFilterProxyModel(parent)
+{
+}
+
+bool VariableSortProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
+{
+    QCollator collator;
+    collator.setNumericMode(true);
+    collator.setCaseSensitivity(Qt::CaseInsensitive);
+    const QString leftString = sourceModel()->data(left).toString();
+    const QString rightString = sourceModel()->data(right).toString();
+    int result = collator.compare(leftString, rightString);
+    return result < 0;
+}
+
+}
diff --git a/debugger/variable/variablesortmodel.h b/debugger/variable/variablesortmodel.h
new file mode 100644
index 000000000..df06b8906
--- /dev/null
+++ b/debugger/variable/variablesortmodel.h
@@ -0,0 +1,45 @@
+/*
+ * KDevelop Debugger Support
+ *
+ * Copyright 2016 Mikhail Ivchenko <ematirov@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU 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_VARIABLESORTMODEL_H
+#define KDEVPLATFORM_VARIABLESORTMODEL_H
+
+#include <QSortFilterProxyModel>
+
+class QModelIndex;
+
+namespace KDevelop
+{
+
+class VariableSortProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+
+public:
+    VariableSortProxyModel(QObject *parent = nullptr);
+
+protected:
+    bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;
+};
+
+}
+
+#endif
diff --git a/debugger/variable/variablewidget.cpp b/debugger/variable/variablewidget.cpp
index 6de9c9a54..0448718c0 100644
--- a/debugger/variable/variablewidget.cpp
+++ b/debugger/variable/variablewidget.cpp
@@ -1,510 +1,511 @@
 // **************************************************************************
 //    begin                : Sun Aug 8 1999
 //    copyright            : (C) 1999 by John Birch
 //    email                : jbb@kdevelop.org
 // **************************************************************************
 // * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
 // **************************************************************************
 // *                                                                        *
 // *   This program is free software; you can redistribute it and/or modify *
 // *   it under the terms of the GNU General Public License as published by *
 // *   the Free Software Foundation; either version 2 of the License, or    *
 // *   (at your option) any later version.                                  *
 // *                                                                        *
 // **************************************************************************
 
 #include "variablewidget.h"
 
 #include <QApplication>
 #include <QCursor>
 #include <QClipboard>
 #include <QKeyEvent>
 #include <QMenu>
 #include <QVBoxLayout>
 
 #include <KHistoryComboBox>
 #include <KLocalizedString>
 #include <QSortFilterProxyModel>
 
 #include "../util/treemodel.h"
 #include "../../interfaces/icore.h"
 #include <interfaces/idebugcontroller.h>
 #include "../interfaces/ivariablecontroller.h"
 #include "variablecollection.h"
+#include "variablesortmodel.h"
 #include "util/debug.h"
 
 /** The variables widget is passive, and is invoked by the rest of the
     code via two main Q_SLOTS:
     - slotDbgStatus
     - slotCurrentFrame
 
     The first is received the program status changes and the second is
     received after current frame in the debugger can possibly changes.
 
     The widget has a list item for each frame/thread combination, with
     variables as children. However, at each moment only one item is shown.
     When handling the slotCurrentFrame, we check if variables for the
     current frame are available. If yes, we simply show the corresponding item.
     Otherwise, we fetch the new data from debugger.
 
     Fetching the data is done by emitting the produceVariablesInfo signal.
     In response, we get slotParametersReady and slotLocalsReady signal,
     in that order.
 
     The data is parsed and changed variables are highlighted. After that,
     we 'trim' variable items that were not reported by gdb -- that is, gone
     out of scope.
 */
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 namespace KDevelop
 {
 
 VariableCollection *variableCollection()
 {
     return ICore::self()->debugController()->variableCollection();
 }
 
 
 VariableWidget::VariableWidget(IDebugController* controller, QWidget *parent)
 : QWidget(parent), variablesRoot_(controller->variableCollection()->root())
 {
   //setWindowIcon(QIcon::fromTheme("math_brace"));
     setWindowIcon(QIcon::fromTheme("debugger"));
     setWindowTitle(i18n("Debugger Variables"));
 
-    m_proxy = new QSortFilterProxyModel;
+    m_proxy = new VariableSortProxyModel;
     varTree_ = new VariableTree(controller, this, m_proxy);
     setFocusProxy(varTree_);
 
     watchVarEditor_ = new KHistoryComboBox( this );
 
     QVBoxLayout *topLayout = new QVBoxLayout(this);
     topLayout->addWidget(varTree_, 10);
     topLayout->addWidget(watchVarEditor_);
     topLayout->setMargin(0);
 
     connect(watchVarEditor_, static_cast<void(KHistoryComboBox::*)(const QString&)>(&KHistoryComboBox::returnPressed),
             this, &VariableWidget::slotAddWatch);
 
     //TODO
     //connect(plugin, SIGNAL(raiseVariableViews()), this, SIGNAL(requestRaise()));
 
     // Setup help items.
 
     setWhatsThis( i18n(
         "<b>Variable tree</b>"
         "The variable tree allows you to see the values of local "
         "variables and arbitrary expressions.<br />"
         "Local variables are displayed automatically and are updated "
         "as you step through your program. "
         "For each expression you enter, you can either evaluate it once, "
         "or \"watch\" it (make it auto-updated). Expressions that are not "
         "auto-updated can be updated manually from the context menu. "
         "Expressions can be renamed to more descriptive names by clicking "
         "on the name column.<br />"
         "To change the value of a variable or an expression, "
         "click on the value.<br />"));
 
     watchVarEditor_->setWhatsThis(
                     i18n("<b>Expression entry</b>"
                          "Type in expression to watch."));
 
 }
 
 void VariableWidget::slotAddWatch(const QString &expression)
 {
     if (!expression.isEmpty())
     {
         watchVarEditor_->addToHistory(expression);
         qCDebug(DEBUGGER) << "Trying to add watch";
         Variable* v = variablesRoot_->watches()->add(expression);
         if (v) {
             /* For watches on structures, we really do want them to be shown
             expanded.  Except maybe for structure with custom pretty printing,
             but will handle that later.
             FIXME: it does not actually works now.
             */
             //QModelIndex index = variableCollection()->indexForItem(v, 0);
             //varTree_->setExpanded(index, true);
         }
         watchVarEditor_->clearEditText();
     }
 }
 
 void VariableWidget::hideEvent(QHideEvent* e)
 {
     QWidget::hideEvent(e);
     variableCollection()->variableWidgetHidden();
 }
 
 void VariableWidget::showEvent(QShowEvent* e)
 {
     QWidget::showEvent(e);
     variableCollection()->variableWidgetShown();
 }
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 VariableTree::VariableTree(IDebugController *controller,
                            VariableWidget *parent, QSortFilterProxyModel *proxy)
     : AsyncTreeView(controller->variableCollection(), proxy, parent)
     , m_proxy(proxy)
 #if 0
 ,
       activePopup_(0),
       toggleWatch_(0)
 #endif
 {
     setRootIsDecorated(true);
     setAllColumnsShowFocus(true);
 
     // setting proxy model
     m_model = static_cast<TreeModel *>(controller->variableCollection());
     m_proxy->setSourceModel(m_model);
     setModel(m_proxy);
     setSortingEnabled(true);
 
     QModelIndex index = controller->variableCollection()->indexForItem(
         controller->variableCollection()->watches(), 0);
     setExpanded(index, true);
 
     m_signalMapper = new QSignalMapper(this);
     setupActions();
 }
 
 
 VariableCollection* VariableTree::collection() const
 {
     Q_ASSERT(qobject_cast<VariableCollection*>(static_cast<QSortFilterProxyModel*>(model())->sourceModel()));
     return static_cast<VariableCollection*>(model());
 }
 
 
 VariableTree::~VariableTree()
 {
 }
 
 void VariableTree::setupActions()
 {
     // TODO decorate this properly to make nice menu title
     m_contextMenuTitle = new QAction(this);
     m_contextMenuTitle->setEnabled(false);
 
     // make Format menu action group
     m_formatMenu = new QMenu(i18n("&Format"), this);
     QActionGroup *ag= new QActionGroup(m_formatMenu);
 
     QAction* act;
 
     act = new QAction(i18n("&Natural"), ag);
     act->setData(Variable::Natural);
     act->setShortcut(Qt::Key_N);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Binary"), ag);
     act->setData(Variable::Binary);
     act->setShortcut(Qt::Key_B);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Octal"), ag);
     act->setData(Variable::Octal);
     act->setShortcut(Qt::Key_O);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Decimal"), ag);
     act->setData(Variable::Decimal);
     act->setShortcut(Qt::Key_D);
     m_formatMenu->addAction(act);
 
     act = new QAction(i18n("&Hexadecimal"), ag);
     act->setData(Variable::Hexadecimal);
     act->setShortcut(Qt::Key_H);
     m_formatMenu->addAction(act);
 
     foreach(QAction* act, m_formatMenu->actions())
     {
         act->setCheckable(true);
         act->setShortcutContext(Qt::WidgetWithChildrenShortcut);
         m_signalMapper->setMapping(act, act->data().toInt());
         connect(act, &QAction::triggered, m_signalMapper, static_cast<void(QSignalMapper::*)()>(&QSignalMapper::map));
         addAction(act);
     }
     connect(m_signalMapper, static_cast<void(QSignalMapper::*)(int)>(&QSignalMapper::mapped), this, &VariableTree::changeVariableFormat);
 
     m_watchDelete = new QAction(
         QIcon::fromTheme("edit-delete"), i18n( "Remove Watch Variable" ), this);
 
     m_watchDelete->setShortcut(Qt::Key_Delete);
     m_watchDelete->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     addAction(m_watchDelete);
     connect(m_watchDelete, &QAction::triggered, this, &VariableTree::watchDelete);
 
     m_copyVariableValue = new QAction(i18n("&Copy Value"), this);
     m_copyVariableValue->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     m_copyVariableValue->setShortcut(QKeySequence::Copy);
     connect(m_copyVariableValue, &QAction::triggered, this, &VariableTree::copyVariableValue);
 
     m_stopOnChange = new QAction(i18n("&Stop on Change"), this);
     connect(m_stopOnChange, &QAction::triggered, this, &VariableTree::stopOnChange);
 }
 
 Variable* VariableTree::selectedVariable() const
 {
     if (selectionModel()->selectedRows().isEmpty()) return 0;
     auto item = selectionModel()->currentIndex().data(TreeModel::ItemRole).value<TreeItem*>();
     if (!item) return 0;
     return dynamic_cast<Variable*>(item);
 }
 
 void VariableTree::contextMenuEvent(QContextMenuEvent* event)
 {
     if (!selectedVariable()) return;
 
     // set up menu
     QMenu contextMenu(this->parentWidget());
     m_contextMenuTitle->setText(selectedVariable()->expression());
     contextMenu.addAction(m_contextMenuTitle);
 
     if(selectedVariable()->canSetFormat())
         contextMenu.addMenu(m_formatMenu);
 
     foreach(QAction* act, m_formatMenu->actions()) {
         if(act->data().toInt()==selectedVariable()->format())
             act->setChecked(true);
     }
 
     if (dynamic_cast<Watches*>(selectedVariable()->parent())) {
         contextMenu.addAction(m_watchDelete);
     }
 
     contextMenu.addSeparator();
     contextMenu.addAction(m_copyVariableValue);
     contextMenu.addAction(m_stopOnChange);
 
     contextMenu.exec(event->globalPos());
 }
 
 void VariableTree::changeVariableFormat(int format)
 {
     if (!selectedVariable()) return;
     selectedVariable()->setFormat(static_cast<Variable::format_t>(format));
 }
 
 void VariableTree::watchDelete()
 {
     if (!selectedVariable()) return;
     if (!dynamic_cast<Watches*>(selectedVariable()->parent())) return;
     selectedVariable()->die();
 }
 
 void VariableTree::copyVariableValue()
 {
     if (!selectedVariable()) return;
     QApplication::clipboard()->setText(selectedVariable()->value());
 }
 
 void VariableTree::stopOnChange()
 {
     if (!selectedVariable()) return;
     IDebugSession *session = ICore::self()->debugController()->currentSession();
     if (session && session->state() != IDebugSession::NotStartedState && session->state() != IDebugSession::EndedState) {
         session->variableController()->addWatchpoint(selectedVariable());
     }
 }
 
 #if 0
 void VariableTree::contextMenuEvent(QContextMenuEvent* event)
 {
     QModelIndex index = indexAt(event->pos());
     if (!index.isValid())
         return;
 
     AbstractVariableItem* item = collection()->itemForIndex(index);
 
     if (RecentItem* recent = qobject_cast<RecentItem*>(item))
     {
         QMenu popup(this);
         popup.addTitle(i18n("Recent Expressions"));
         QAction* remove = popup.addAction(QIcon::fromTheme("editdelete"), i18n("Remove All"));
         QAction* reevaluate = popup.addAction(QIcon::fromTheme("reload"), i18n("Re-evaluate All"));
 
         if (controller()->stateIsOn(s_dbgNotStarted))
             reevaluate->setEnabled(false);
 
         QAction* res = popup.exec(QCursor::pos());
 
         if (res == remove)
         {
             collection()->deleteItem(recent);
         }
         else if (res == reevaluate)
         {
             foreach (AbstractVariableItem* item, recent->children())
             {
                 if (VariableItem* variable = qobject_cast<VariableItem*>(item))
                     variable->updateValue();
             }
         }
     }
     else
     {
         activePopup_ = new QMenu(this);
         QMenu format(this);
 
         QAction* remember = 0;
         QAction* remove = 0;
         QAction* reevaluate = 0;
         QAction* watch = 0;
 
         QAction* natural = 0;
         QAction* hex = 0;
         QAction* decimal = 0;
         QAction* character = 0;
         QAction* binary = 0;
 
 #define MAYBE_DISABLE(action) if (!var->isAlive()) action->setEnabled(false)
 
         VariableItem* var = qobject_cast<VariableItem*>(item);
 
         AbstractVariableItem* root = item->abstractRoot();
 
         RecentItem* recentRoot = qobject_cast<RecentItem*>(root);
 
         if (!recentRoot)
         {
             remember = activePopup_->addAction(QIcon::fromTheme("draw-freehand"), i18n("Remember Value"));
             MAYBE_DISABLE(remember);
         }
 
         if (!recentRoot) {
             watch = activePopup_->addAction(i18n("Watch Variable"));
             MAYBE_DISABLE(watch);
         }
 
         if (recentRoot) {
             reevaluate = activePopup_->addAction(QIcon::fromTheme("reload"), i18n("Reevaluate Expression"));
             MAYBE_DISABLE(reevaluate);
             remove = activePopup_->addAction(QIcon::fromTheme("editdelete"), i18n("Remove Expression"));
             remove->setShortcut(Qt::Key_Delete);
         }
 
         if (var)
         {
             toggleWatch_ = activePopup_->addAction( i18n("Data write breakpoint") );
             toggleWatch_->setCheckable(true);
             toggleWatch_->setEnabled(false);
         }
 
         /* This code can be executed when debugger is stopped,
            and we invoke popup menu on a var under "recent expressions"
            just to delete it. */
         if (var && var->isAlive() && !controller()->stateIsOn(s_dbgNotStarted)) {
             GDBCommand* cmd =  new GDBCommand(DataEvaluateExpression,
                                                 QStringLiteral("&%1")
                                                 .arg(var->gdbExpression()));
             cmd->setHandler(this, &VariableTree::handleAddressComputed, true /*handles error*/);
             cmd->setThread(var->thread());
             cmd->setFrame(var->frame());
             controller_->addCommand(cmd);
         }
 
 
         QAction* res = activePopup_->exec(event->globalPos());
         delete activePopup_;
         activePopup_ = 0;
 
         if (res == remember)
         {
             if (var)
             {
                 ((VariableWidget*)parent())->
                     slotEvaluateExpression(var->gdbExpression());
             }
         }
         else if (res == watch)
         {
             if (var)
             {
                 ((VariableWidget*)parent())->
                     slotAddWatchVariable(var->gdbExpression());
             }
         }
         else if (res == remove)
         {
             delete item;
         }
         else if (res == toggleWatch_)
         {
             if (var)
                 emit toggleWatchpoint(var->gdbExpression());
         }
         else if (res == reevaluate)
         {
             if (var)
             {
                 var->updateValue();
             }
         }
 
         event->accept();
     }
 }
 
 
 void VariableTree::updateCurrentFrame()
 {
 }
 
 // **************************************************************************
 
 void VariableTree::handleAddressComputed(const GDBMI::ResultRecord& r)
 {
     if (r.reason == "error")
     {
         // Not lvalue, leave item disabled.
         return;
     }
 
     if (activePopup_)
     {
         toggleWatch_->setEnabled(true);
 
         //quint64 address = r["value"].literal().toULongLong(0, 16);
         /*if (breakpointWidget_->hasWatchpointForAddress(address))
         {
             toggleWatch_->setChecked(true);
         }*/
     }
 }
 
 VariableCollection * VariableTree::collection() const
 {
     return controller_->variables();
 }
 
 GDBController * VariableTree::controller() const
 {
     return controller_;
 }
 
 void VariableTree::showEvent(QShowEvent * event)
 {
     Q_UNUSED(event)
 
     for (int i = 0; i < model()->columnCount(); ++i)
         resizeColumnToContents(i);
 }
 #endif
 
 // **************************************************************************
 // **************************************************************************
 // **************************************************************************
 
 }
 
diff --git a/outputview/outputexecutejob.cpp b/outputview/outputexecutejob.cpp
index 9cfd0401b..ca15e1a91 100644
--- a/outputview/outputexecutejob.cpp
+++ b/outputview/outputexecutejob.cpp
@@ -1,517 +1,520 @@
 /* This file is part of KDevelop
 Copyright 2012 Ivan Shapovalov <intelfx100@gmail.com>
 
 This library 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 library 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #include "outputexecutejob.h"
 #include "outputmodel.h"
 #include "outputdelegate.h"
 #include "debug.h"
 #include <util/environmentgrouplist.h>
 #include <util/processlinemaker.h>
 #include <KProcess>
 #include <KLocalizedString>
 #include <KShell>
 #include <QFileInfo>
 #include <QDir>
 
 namespace KDevelop
 {
 
 class OutputExecuteJobPrivate
 {
 public:
     OutputExecuteJobPrivate( KDevelop::OutputExecuteJob* owner );
 
     void childProcessStdout();
     void childProcessStderr();
 
     void emitProgress(const IFilterStrategy::Progress& progress);
 
     QString joinCommandLine() const;
     QString getJobName();
 
     template< typename T >
     static void mergeEnvironment( QProcessEnvironment& dest, const T& src );
     QProcessEnvironment effectiveEnvironment() const;
     QStringList effectiveCommandLine() const;
 
     OutputExecuteJob* m_owner;
 
     KProcess* m_process;
     ProcessLineMaker* m_lineMaker;
     OutputExecuteJob::JobStatus m_status;
     OutputExecuteJob::JobProperties m_properties;
     OutputModel::OutputFilterStrategy m_filteringStrategy;
     QScopedPointer<IFilterStrategy> m_filteringStrategyPtr;
     QStringList m_arguments;
     QStringList m_privilegedExecutionCommand;
     QUrl m_workingDirectory;
     QString m_environmentProfile;
     QHash<QString, QString> m_environmentOverrides;
     QString m_jobName;
     bool m_outputStarted;
 };
 
 OutputExecuteJobPrivate::OutputExecuteJobPrivate( OutputExecuteJob* owner ) :
     m_owner( owner ),
     m_process( new KProcess( m_owner ) ),
     m_lineMaker( new ProcessLineMaker( m_owner ) ), // do not assign process to the line maker as we'll feed it data ourselves
     m_status( OutputExecuteJob::JobNotStarted ),
     m_properties( OutputExecuteJob::DisplayStdout ),
     m_filteringStrategy( OutputModel::NoFilter ),
     m_outputStarted( false )
 {
 }
 
 OutputExecuteJob::OutputExecuteJob( QObject* parent, OutputJob::OutputJobVerbosity verbosity ):
     OutputJob( parent, verbosity ),
     d( new OutputExecuteJobPrivate( this ) )
 {
     d->m_process->setOutputChannelMode( KProcess::SeparateChannels );
 
     connect( d->m_process, static_cast<void(KProcess::*)(int,QProcess::ExitStatus)>(&KProcess::finished),
              this, &OutputExecuteJob::childProcessExited );
     connect( d->m_process, static_cast<void(KProcess::*)(QProcess::ProcessError)>(&KProcess::error),
              this, &OutputExecuteJob::childProcessError );
     connect( d->m_process, &KProcess::readyReadStandardOutput,
              this, [=] { d->childProcessStdout(); } );
     connect( d->m_process, &KProcess::readyReadStandardError,
              this, [=] { d->childProcessStderr(); } );
 }
 
 OutputExecuteJob::~OutputExecuteJob()
 {
     if( d->m_process->state() != QProcess::NotRunning ) {
         doKill();
     }
     Q_ASSERT( d->m_process->state() == QProcess::NotRunning );
     delete d;
 }
 
 OutputExecuteJob::JobStatus OutputExecuteJob::status() const
 {
     return d->m_status;
 }
 
 OutputModel* OutputExecuteJob::model() const
 {
     return dynamic_cast<OutputModel*> ( OutputJob::model() );
 }
 
 QStringList OutputExecuteJob::commandLine() const
 {
     return d->m_arguments;
 }
 
 OutputExecuteJob& OutputExecuteJob::operator<<( const QString& argument )
 {
     d->m_arguments << argument;
     return *this;
 }
 
 OutputExecuteJob& OutputExecuteJob::operator<<( const QStringList& arguments )
 {
     d->m_arguments << arguments;
     return *this;
 }
 
 QStringList OutputExecuteJob::privilegedExecutionCommand() const
 {
     return d->m_privilegedExecutionCommand;
 }
 
 void OutputExecuteJob::setPrivilegedExecutionCommand( const QStringList& command )
 {
     d->m_privilegedExecutionCommand = command;
 }
 
 void OutputExecuteJob::setJobName( const QString& name )
 {
     d->m_jobName = name;
     QString jobName = d->getJobName();
     setObjectName( jobName );
     setTitle( jobName );
 }
 
 QUrl OutputExecuteJob::workingDirectory() const
 {
     return d->m_workingDirectory;
 }
 
 void OutputExecuteJob::setWorkingDirectory( const QUrl& url )
 {
     d->m_workingDirectory = url;
 }
 
 void OutputExecuteJob::start()
 {
     Q_ASSERT( d->m_status == JobNotStarted );
     d->m_status = JobRunning;
 
     const bool isBuilder = d->m_properties.testFlag( IsBuilderHint );
 
     const QUrl effectiveWorkingDirectory = workingDirectory();
     if( effectiveWorkingDirectory.isEmpty() ) {
         if( d->m_properties.testFlag( NeedWorkingDirectory ) ) {
             // A directory is not given, but we need it.
             setError( InvalidWorkingDirectoryError );
             if( isBuilder ) {
                 setErrorText( i18n( "No build directory specified for a builder job." ) );
             } else {
                 setErrorText( i18n( "No working directory specified for a process." ) );
             }
             return emitResult();
         }
 
         setModel( new OutputModel );
     } else {
         // Basic sanity checks.
         if( !effectiveWorkingDirectory.isValid() ) {
             setError( InvalidWorkingDirectoryError );
             if( isBuilder ) {
                 setErrorText( i18n( "Invalid build directory '%1'", effectiveWorkingDirectory.toDisplayString(QUrl::PreferLocalFile) ) );
             } else {
                 setErrorText( i18n( "Invalid working directory '%1'", effectiveWorkingDirectory.toDisplayString(QUrl::PreferLocalFile) ) );
             }
             return emitResult();
         } else if( !effectiveWorkingDirectory.isLocalFile() ) {
             setError( InvalidWorkingDirectoryError );
             if( isBuilder ) {
                 setErrorText( i18n( "Build directory '%1' is not a local path", effectiveWorkingDirectory.toDisplayString(QUrl::PreferLocalFile) ) );
             } else {
                 setErrorText( i18n( "Working directory '%1' is not a local path", effectiveWorkingDirectory.toDisplayString(QUrl::PreferLocalFile) ) );
             }
             return emitResult();
         }
 
         QFileInfo workingDirInfo( effectiveWorkingDirectory.toLocalFile() );
         if( !workingDirInfo.isDir() ) {
             // If a working directory does not actually exist, either bail out or create it empty,
             // depending on what we need by properties.
             // We use a dedicated bool variable since !isDir() may also mean that it exists,
             // but is not a directory, or a symlink to an inexistent object.
             bool successfullyCreated = false;
             if( !d->m_properties.testFlag( CheckWorkingDirectory ) ) {
                 successfullyCreated = QDir().mkdir( effectiveWorkingDirectory.toLocalFile() );
             }
             if( !successfullyCreated ) {
                 setError( InvalidWorkingDirectoryError );
                 if( isBuilder ) {
                     setErrorText( i18n( "Build directory '%1' does not exist or is not a directory", effectiveWorkingDirectory.toDisplayString(QUrl::PreferLocalFile) ) );
                 } else {
                     setErrorText( i18n( "Working directory '%1' does not exist or is not a directory", effectiveWorkingDirectory.toDisplayString(QUrl::PreferLocalFile) ) );
                 }
                 return emitResult();
             }
         }
 
         setModel( new OutputModel( effectiveWorkingDirectory ) );
     }
     Q_ASSERT( model() );
 
     if (d->m_filteringStrategy != OutputModel::NoFilter) {
         model()->setFilteringStrategy(d->m_filteringStrategy);
     } else {
         model()->setFilteringStrategy(d->m_filteringStrategyPtr.take());
     }
 
     setDelegate( new OutputDelegate );
 
     connect(model(), &OutputModel::progress, this, [&](const IFilterStrategy::Progress& progress) {
         d->emitProgress(progress);
     });
 
     // Slots hasRawStdout() and hasRawStderr() are responsible
     // for feeding raw data to the line maker; so property-based channel filtering is implemented there.
     if( d->m_properties.testFlag( PostProcessOutput ) ) {
         connect( d->m_lineMaker, &ProcessLineMaker::receivedStdoutLines,
                  this, &OutputExecuteJob::postProcessStdout );
         connect( d->m_lineMaker, &ProcessLineMaker::receivedStderrLines,
                  this, &OutputExecuteJob::postProcessStderr );
     } else {
         connect( d->m_lineMaker, &ProcessLineMaker::receivedStdoutLines, model(),
                  &OutputModel::appendLines );
         connect( d->m_lineMaker, &ProcessLineMaker::receivedStderrLines, model(),
                  &OutputModel::appendLines );
     }
 
     if( !d->m_properties.testFlag( NoSilentOutput ) || verbosity() != Silent ) {
         d->m_outputStarted = true;
         startOutput();
     }
 
     const QString joinedCommandLine = d->joinCommandLine();
     QString headerLine;
     if( !effectiveWorkingDirectory.isEmpty() ) {
         headerLine = effectiveWorkingDirectory.toString( QUrl::PreferLocalFile | QUrl::StripTrailingSlash ) + "> " + joinedCommandLine;
     } else {
         headerLine = joinedCommandLine;
     }
     model()->appendLine( headerLine );
 
     if( !effectiveWorkingDirectory.isEmpty() ) {
         d->m_process->setWorkingDirectory( effectiveWorkingDirectory.toLocalFile() );
     }
     d->m_process->setProcessEnvironment( d->effectiveEnvironment() );
     d->m_process->setProgram( d->effectiveCommandLine() );
 
     qCDebug(OUTPUTVIEW) << "Starting:" << d->m_process->program().join(" ") << "in" << d->m_process->workingDirectory();
     d->m_process->start();
 }
 
 bool OutputExecuteJob::doKill()
 {
     const int terminateKillTimeout = 1000; // msecs
 
     if( d->m_status != JobRunning )
         return true;
     d->m_status = JobCanceled;
 
     d->m_process->terminate();
     bool terminated = d->m_process->waitForFinished( terminateKillTimeout );
     if( !terminated ) {
         d->m_process->kill();
         terminated = d->m_process->waitForFinished( terminateKillTimeout );
     }
     d->m_lineMaker->flushBuffers();
     if( terminated ) {
-        model()->appendLine( i18n( "*** Aborted ***" ) );
+        model()->appendLine( i18n( "*** Killed process ***" ) );
     } else {
         // It survived SIGKILL, leave it alone...
         model()->appendLine( i18n( "*** Warning: could not kill the process ***" ) );
     }
     return true;
 }
 
 void OutputExecuteJob::childProcessError( QProcess::ProcessError processError )
 {
     // This can be called twice: one time via an error() signal, and second - from childProcessExited().
     // Avoid doing things in second time.
     if( d->m_status != OutputExecuteJob::JobRunning )
         return;
     d->m_status = OutputExecuteJob::JobFailed;
 
     QString errorValue;
     switch( processError ) {
         case QProcess::FailedToStart:
             errorValue = i18n("%1 has failed to start", commandLine().first());
             break;
 
         case QProcess::Crashed:
             errorValue = i18n("%1 has crashed", commandLine().first());
             break;
 
         case QProcess::ReadError:
             errorValue = i18n("Read error");
             break;
 
         case QProcess::WriteError:
             errorValue = i18n("Write error");
             break;
 
         case QProcess::Timedout:
             errorValue = i18n("Waiting for the process has timed out");
             break;
 
         default:
         case QProcess::UnknownError:
             errorValue = i18n("Exit code %1", d->m_process->exitCode());
             break;
     }
 
     // Show the toolview if it's hidden for the user to be able to diagnose errors.
     if( !d->m_outputStarted ) {
         d->m_outputStarted = true;
         startOutput();
     }
 
     setError( FailedShownError );
     setErrorText( errorValue );
     d->m_lineMaker->flushBuffers();
     model()->appendLine( i18n("*** Failure: %1 ***", errorValue) );
     emitResult();
 }
 
 void OutputExecuteJob::childProcessExited( int exitCode, QProcess::ExitStatus exitStatus )
 {
     if( d->m_status != JobRunning )
         return;
 
     if( exitStatus == QProcess::CrashExit ) {
         childProcessError( QProcess::Crashed );
     } else if ( exitCode != 0 ) {
         childProcessError( QProcess::UnknownError );
     } else {
         d->m_status = JobSucceeded;
         d->m_lineMaker->flushBuffers();
         model()->appendLine( i18n("*** Finished ***") );
         emitResult();
     }
 }
 
 void OutputExecuteJobPrivate::childProcessStdout()
 {
     QByteArray out = m_process->readAllStandardOutput();
     if( m_properties.testFlag( OutputExecuteJob::DisplayStdout ) ) {
         m_lineMaker->slotReceivedStdout( out );
     }
 }
 
 void OutputExecuteJobPrivate::childProcessStderr()
 {
     QByteArray err = m_process->readAllStandardError();
     if( m_properties.testFlag( OutputExecuteJob::DisplayStderr ) ) {
         m_lineMaker->slotReceivedStderr( err );
     }
 }
 
 void OutputExecuteJobPrivate::emitProgress(const IFilterStrategy::Progress& progress)
 {
     m_owner->emitPercent(progress.percent, 100);
 
     if (progress.percent == 100) {
         m_owner->infoMessage(m_owner, i18n("Build finished"));
     } else {
         m_owner->infoMessage(m_owner, progress.status);
     }
 }
 
 void OutputExecuteJob::postProcessStdout( const QStringList& lines )
 {
     model()->appendLines( lines );
 }
 
 void OutputExecuteJob::postProcessStderr( const QStringList& lines )
 {
     model()->appendLines( lines );
 }
 
 void OutputExecuteJob::setFilteringStrategy( OutputModel::OutputFilterStrategy strategy )
 {
     d->m_filteringStrategy = strategy;
 
     // clear the other
     d->m_filteringStrategyPtr.reset(nullptr);
 }
 
 void OutputExecuteJob::setFilteringStrategy(IFilterStrategy* filterStrategy)
 {
     d->m_filteringStrategyPtr.reset(filterStrategy);
 
     // clear the other
     d->m_filteringStrategy = OutputModel::NoFilter;
 }
 
 OutputExecuteJob::JobProperties OutputExecuteJob::properties() const
 {
     return d->m_properties;
 }
 
 void OutputExecuteJob::setProperties( OutputExecuteJob::JobProperties properties, bool override )
 {
     if( override ) {
         d->m_properties = properties;
     } else {
         d->m_properties |= properties;
     }
 }
 
 void OutputExecuteJob::unsetProperties( OutputExecuteJob::JobProperties properties )
 {
     d->m_properties &= ~properties;
 }
 
 QString OutputExecuteJob::environmentProfile() const
 {
     return d->m_environmentProfile;
 }
 
 void OutputExecuteJob::setEnvironmentProfile( const QString& profile )
 {
     d->m_environmentProfile = profile;
 }
 
 void OutputExecuteJob::addEnvironmentOverride( const QString& name, const QString& value )
 {
     d->m_environmentOverrides[name] = value;
 }
 
 void OutputExecuteJob::removeEnvironmentOverride( const QString& name )
 {
     d->m_environmentOverrides.remove( name );
 }
 
 template< typename T >
 void OutputExecuteJobPrivate::mergeEnvironment( QProcessEnvironment& dest, const T& src )
 {
     for( typename T::const_iterator it = src.begin(); it != src.end(); ++it ) {
         dest.insert( it.key(), it.value() );
     }
 }
 
 QProcessEnvironment OutputExecuteJobPrivate::effectiveEnvironment() const
 {
-    QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
     const EnvironmentGroupList environmentGroup( KSharedConfig::openConfig() );
     QString environmentProfile = m_owner->environmentProfile();
     if( environmentProfile.isEmpty() ) {
         environmentProfile = environmentGroup.defaultGroup();
     }
-    OutputExecuteJobPrivate::mergeEnvironment( environment, environmentGroup.variables( environmentProfile ) );
+    QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
+    auto userEnv = environmentGroup.variables(environmentProfile);
+    expandVariables(userEnv, environment);
+
+    OutputExecuteJobPrivate::mergeEnvironment( environment, userEnv );
     OutputExecuteJobPrivate::mergeEnvironment( environment, m_environmentOverrides );
     if( m_properties.testFlag( OutputExecuteJob::PortableMessages ) ) {
         environment.remove( "LC_ALL" );
         environment.insert( "LC_MESSAGES", "C" );
     }
     return environment;
 }
 
 QString OutputExecuteJobPrivate::joinCommandLine() const
 {
     return KShell::joinArgs( effectiveCommandLine() );
 }
 
 QStringList OutputExecuteJobPrivate::effectiveCommandLine() const
 {
     // If we need to use a su-like helper, invoke it as
     // "helper -- our command line".
     QStringList privilegedCommand = m_owner->privilegedExecutionCommand();
     if( !privilegedCommand.isEmpty() ) {
         return QStringList() << m_owner->privilegedExecutionCommand() << "--" << m_owner->commandLine();
     } else {
         return m_owner->commandLine();
     }
 }
 
 QString OutputExecuteJobPrivate::getJobName()
 {
     const QString joinedCommandLine = joinCommandLine();
     if( m_properties.testFlag( OutputExecuteJob::AppendProcessString ) ) {
         if( !m_jobName.isEmpty() ) {
             return m_jobName + ": " + joinedCommandLine;
         } else {
             return joinedCommandLine;
         }
     } else {
         return m_jobName;
     }
 }
 
 } // namespace KDevelop
 
 #include "moc_outputexecutejob.cpp"
diff --git a/plugins/execute/nativeappjob.cpp b/plugins/execute/nativeappjob.cpp
index 8576c3db3..20f97c62a 100644
--- a/plugins/execute/nativeappjob.cpp
+++ b/plugins/execute/nativeappjob.cpp
@@ -1,243 +1,146 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 
     This library 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 library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "nativeappjob.h"
 
 #include <QDebug>
 #include <QFileInfo>
 #include <QMessageBox>
 
 #include <KLocalizedString>
-#include <KProcess>
 #include <KShell>
 #include <KSharedConfig>
-#include <KCompositeJob>
 
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/iruncontroller.h>
 #include <outputview/outputmodel.h>
-#include <outputview/outputdelegate.h>
-#include <util/processlinemaker.h>
 #include <util/environmentgrouplist.h>
 
 #include <interfaces/icore.h>
-#include <interfaces/iuicontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <project/projectmodel.h>
 
 #include "iexecuteplugin.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 NativeAppJob::NativeAppJob(QObject* parent, KDevelop::ILaunchConfiguration* cfg)
-    : KDevelop::OutputJob( parent ), proc(0)
+    : KDevelop::OutputExecuteJob( parent )
     , m_cfgname(cfg->name())
 {
     setCapabilities(Killable);
 
     IExecutePlugin* iface = KDevelop::ICore::self()->pluginController()->pluginForExtension("org.kdevelop.IExecutePlugin", "kdevexecute")->extension<IExecutePlugin>();
     Q_ASSERT(iface);
 
     KDevelop::EnvironmentGroupList l(KSharedConfig::openConfig());
     QString envgrp = iface->environmentGroup(cfg);
 
     QString err;
     QUrl executable = iface->executable( cfg, err );
 
     if( !err.isEmpty() )
     {
         setError( -1 );
         setErrorText( err );
         return;
     }
 
     if( envgrp.isEmpty() )
     {
         qWarning() << "Launch Configuration:" << cfg->name() << i18n("No environment group specified, looks like a broken "
                        "configuration, please check run configuration '%1'. "
                        "Using default environment group.", cfg->name() );
         envgrp = l.defaultGroup();
     }
+    setEnvironmentProfile(envgrp);
 
     QStringList arguments = iface->arguments( cfg, err );
     if( !err.isEmpty() )
     {
         setError( -2 );
         setErrorText( err );
     }
 
     if( error() != 0 )
     {
         qWarning() << "Launch Configuration:" << cfg->name() << "oops, problem" << errorText();
         return;
     }
 
-    proc = new KProcess( this );
-
-    lineMaker = new KDevelop::ProcessLineMaker( proc, this );
-
     setStandardToolView(KDevelop::IOutputView::RunView);
     setBehaviours(KDevelop::IOutputView::AllowUserClose | KDevelop::IOutputView::AutoScroll);
-    OutputModel* m = new OutputModel;
-    m->setFilteringStrategy(OutputModel::NativeAppErrorFilter);
-    setModel(m);
-    setDelegate( new KDevelop::OutputDelegate );
-
-    connect( lineMaker, &ProcessLineMaker::receivedStdoutLines, model(), &OutputModel::appendLines );
-    connect( proc, static_cast<void(KProcess::*)(QProcess::ProcessError)>(&KProcess::error), this, &NativeAppJob::processError );
-    connect( proc, static_cast<void(KProcess::*)(int,QProcess::ExitStatus)>(&KProcess::finished), this, &NativeAppJob::processFinished );
+    setFilteringStrategy(OutputModel::NativeAppErrorFilter);
+    setProperties(DisplayStdout | DisplayStderr);
 
     // Now setup the process parameters
 
-    proc->setEnvironment( l.createEnvironment( envgrp, proc->systemEnvironment()) );
     QUrl wc = iface->workingDirectory( cfg );
-    if( !wc.isValid() || wc.isEmpty() )
-    {
+    if( !wc.isValid() || wc.isEmpty() ) {
         wc = QUrl::fromLocalFile( QFileInfo( executable.toLocalFile() ).absolutePath() );
     }
-    proc->setWorkingDirectory( wc.toLocalFile() );
-    proc->setProperty( "executable", executable );
+    setWorkingDirectory( wc );
 
     qCDebug(PLUGIN_EXECUTE) << "setting app:" << executable << arguments;
 
-    proc->setOutputChannelMode(KProcess::MergedChannels);
-
     if (iface->useTerminal(cfg)) {
         QStringList args = KShell::splitArgs(iface->terminal(cfg));
         for (QStringList::iterator it = args.begin(); it != args.end(); ++it) {
             if (*it == "%exe") {
                 *it = KShell::quoteArg(executable.toLocalFile());
             } else if (*it == "%workdir") {
                 *it = KShell::quoteArg(wc.toLocalFile());
             }
         }
         args.append( arguments );
-        proc->setProgram( args );
+        *this << args;
     } else {
-        proc->setProgram( executable.toLocalFile(), arguments );
+        *this << executable.toLocalFile();
+        *this << arguments;
     }
 
-    setObjectName(cfg->name());
+    setJobName(cfg->name());
 }
 
 NativeAppJob* findNativeJob(KJob* j)
 {
     NativeAppJob* job = qobject_cast<NativeAppJob*>(j);
     if (!job) {
         const QList<NativeAppJob*> jobs = j->findChildren<NativeAppJob*>();
         if (!jobs.isEmpty())
             job = jobs.first();
     }
     return job;
 }
 
 void NativeAppJob::start()
 {
     // we kill any execution of the configuration
     foreach(KJob* j, ICore::self()->runController()->currentJobs()) {
         NativeAppJob* job = findNativeJob(j);
         if (job && job != this && job->m_cfgname == m_cfgname) {
-            QMessageBox::StandardButton button = QMessageBox::question(Q_NULLPTR, i18n("Job already running"), i18n("'%1' is already being executed. Should we kill the previous instance?", m_cfgname));
-            if (button != QMessageBox::NoButton)
+            QMessageBox::StandardButton button = QMessageBox::question(nullptr, i18n("Job already running"), i18n("'%1' is already being executed. Should we kill the previous instance?", m_cfgname));
+            if (button != QMessageBox::No)
                 j->kill();
         }
     }
 
-    qCDebug(PLUGIN_EXECUTE) << "launching?" << proc;
-    if( proc )
-    {
-        startOutput();
-        appendLine( i18n("Starting: %1", proc->program().join(" ") ) );
-        proc->start();
-    } else
-    {
-        qWarning() << "No process, something went wrong when creating the job";
-        // No process means we've returned early on from the constructor, some bad error happened
-        emitResult();
-    }
-}
-
-bool NativeAppJob::doKill()
-{
-    if( proc ) {
-        proc->kill();
-        appendLine( i18n( "*** Killed Application ***" ) );
-    }
-    return true;
-}
-
-void NativeAppJob::processFinished( int exitCode , QProcess::ExitStatus status )
-{
-    if (!model()) {
-        outputDone();
-        return;
-    }
-
-    connect(model(), &OutputModel::allDone, this, &NativeAppJob::outputDone);
-    lineMaker->flushBuffers();
-
-    if (exitCode == 0 && status == QProcess::NormalExit) {
-        appendLine( i18n("*** Exited normally ***") );
-    } else if (status == QProcess::NormalExit) {
-        appendLine( i18n("*** Exited with return code: %1 ***", QString::number(exitCode)) );
-        setError(OutputJob::FailedShownError);
-    } else if (error() == KJob::KilledJobError) {
-        appendLine( i18n("*** Process aborted ***") );
-        setError(KJob::KilledJobError);
-    } else {
-        appendLine( i18n("*** Crashed with return code: %1 ***", QString::number(exitCode)) );
-        setError(OutputJob::FailedShownError);
-    }
-
-    model()->ensureAllDone();
-}
-
-void NativeAppJob::outputDone()
-{
-    emitResult();
-}
-
-void NativeAppJob::processError( QProcess::ProcessError error )
-{
-    if( error == QProcess::FailedToStart )
-    {
-        setError( FailedShownError );
-        QString errmsg =  i18n("*** Could not start program '%1'. Make sure that the "
-                           "path is specified correctly ***", proc->program().join(" ") );
-        appendLine( errmsg );
-        setErrorText( errmsg );
-        emitResult();
-    }
-    qCDebug(PLUGIN_EXECUTE) << "Process error";
+    OutputExecuteJob::start();
 }
-
-void NativeAppJob::appendLine(const QString& l)
-{
-    if (KDevelop::OutputModel* m = model()) {
-        m->appendLine(l);
-    }
-}
-
-KDevelop::OutputModel* NativeAppJob::model()
-{
-    return dynamic_cast<KDevelop::OutputModel*>( OutputJob::model() );
-}
-
-
diff --git a/plugins/execute/nativeappjob.h b/plugins/execute/nativeappjob.h
index cd88cc58e..45a287aa5 100644
--- a/plugins/execute/nativeappjob.h
+++ b/plugins/execute/nativeappjob.h
@@ -1,56 +1,47 @@
 /*  This file is part of KDevelop
     Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 
     This library 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 library 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
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_PLUGIN_NATIVEAPPJOB_H
 #define KDEVPLATFORM_PLUGIN_NATIVEAPPJOB_H
 
+#include <outputview/outputexecutejob.h>
+
 #include <QtCore/QProcess>
-#include <outputview/outputjob.h>
 
 namespace KDevelop
 {
 class ILaunchConfiguration;
-class ProcessLineMaker;
-class OutputModel;
 }
 
 class KProcess;
 
-class NativeAppJob : public KDevelop::OutputJob
+class NativeAppJob : public KDevelop::OutputExecuteJob
 {
-Q_OBJECT
+    Q_OBJECT
+
 public:
     NativeAppJob( QObject* parent, KDevelop::ILaunchConfiguration* cfg );
+
     void start() override;
-    bool doKill() override;
-    KDevelop::OutputModel* model();
-private slots:
-    void processError(QProcess::ProcessError);
-    void processFinished(int,QProcess::ExitStatus);
-    void outputDone();
 
 private:
-    void appendLine(const QString &l);
-
-    KProcess* proc;
-    KDevelop::ProcessLineMaker* lineMaker;
     QString m_cfgname;
 };
 
 #endif
diff --git a/sublime/mainwindow_p.cpp b/sublime/mainwindow_p.cpp
index 4150eb6b6..3ab490cdb 100644
--- a/sublime/mainwindow_p.cpp
+++ b/sublime/mainwindow_p.cpp
@@ -1,823 +1,823 @@
 /***************************************************************************
  *   Copyright 2006-2009 Alexander Dymo  <adymo@kdevelop.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 Library 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 "mainwindow_p.h"
 
 #include <QLayout>
 #include <QSplitter>
 #include <QTimer>
 #include <QToolBar>
 
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 
 #include "area.h"
 #include "view.h"
 #include "areaindex.h"
 #include "document.h"
 #include "container.h"
 #include "controller.h"
 #include "mainwindow.h"
 #include "idealcontroller.h"
 #include "holdupdates.h"
 #include "idealbuttonbarwidget.h"
 #include "sublimedebug.h"
 
 class IdealToolBar : public QToolBar
 {
     Q_OBJECT
     public:
         explicit IdealToolBar(const QString& title, bool hideWhenEmpty, Sublime::IdealButtonBarWidget* buttons, QMainWindow* parent)
             : QToolBar(title, parent)
             , m_timer(nullptr)
             , m_buttons(buttons)
             , m_hideWhenEmpty(hideWhenEmpty)
             , m_requestedVisibility(true)
         {
             setMovable(false);
             setFloatable(false);
             setObjectName(title);
             layout()->setMargin(0);
 
             addWidget(m_buttons);
 
             if (m_hideWhenEmpty) {
                 m_timer = new QTimer(this);
                 m_timer->setInterval(100);
                 m_timer->setSingleShot(true);
                 connect(m_timer, &QTimer::timeout, this, &IdealToolBar::refresh);
                 connect(this, &IdealToolBar::visibilityChanged, m_timer, static_cast<void(QTimer::*)()>(&QTimer::start));
                 connect(m_buttons, &Sublime::IdealButtonBarWidget::emptyChanged, m_timer, static_cast<void(QTimer::*)()>(&QTimer::start));
             }
         }
 
         void setVisible(bool visible) override
         {
             QToolBar::setVisible(visible);
 
             m_requestedVisibility = visible;
 
             if (m_hideWhenEmpty && visible) {
                 m_timer->start();
             }
         }
 
     private slots:
         void refresh()
         {
             setVisible(m_requestedVisibility && !m_buttons->isEmpty());
         }
 
     private:
         QTimer* m_timer;
         Sublime::IdealButtonBarWidget* m_buttons;
         const bool m_hideWhenEmpty;
         bool m_requestedVisibility;
 };
 
 namespace Sublime {
 
 MainWindowPrivate::MainWindowPrivate(MainWindow *w, Controller* controller)
 :controller(controller), area(0), activeView(0), activeToolView(0), bgCentralWidget(0),
  ignoreDockShown(false), autoAreaSettingsSave(false), m_mainWindow(w)
 {
     KActionCollection *ac = m_mainWindow->actionCollection();
 
     m_concentrationModeAction = new QAction(i18n("Concentration Mode"), this);
     m_concentrationModeAction->setIcon(QIcon::fromTheme(QStringLiteral("page-zoom")));
     m_concentrationModeAction->setToolTip(i18n("Removes most of the controls so you can focus on what matters."));
     m_concentrationModeAction->setCheckable(true);
     m_concentrationModeAction->setChecked(false);
     ac->setDefaultShortcut(m_concentrationModeAction, Qt::META | Qt::Key_C);
     connect(m_concentrationModeAction, &QAction::toggled, this, &MainWindowPrivate::restoreConcentrationMode);
     ac->addAction(QStringLiteral("toggle_concentration_mode"), m_concentrationModeAction);
 
     QAction* action = new QAction(i18n("Show Left Dock"), this);
     action->setCheckable(true);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_Left);
     connect(action, &QAction::toggled, this, &MainWindowPrivate::showLeftDock);
 
     ac->addAction(QStringLiteral("show_left_dock"), action);
 
     action = new QAction(i18n("Show Right Dock"), this);
     action->setCheckable(true);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_Right);
     connect(action, &QAction::toggled, this, &MainWindowPrivate::showRightDock);
     ac->addAction(QStringLiteral("show_right_dock"), action);
 
     action = new QAction(i18n("Show Bottom Dock"), this);
     action->setCheckable(true);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_Down);
     connect(action, &QAction::toggled, this, &MainWindowPrivate::showBottomDock);
     ac->addAction(QStringLiteral("show_bottom_dock"), action);
 
     action = new QAction(i18nc("@action", "Focus Editor"), this);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_E);
     connect(action, &QAction::triggered, this, &MainWindowPrivate::focusEditor);
     ac->addAction(QStringLiteral("focus_editor"), action);
 
     action = new QAction(i18n("Hide/Restore Docks"), this);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_Up);
     connect(action, &QAction::triggered, this, &MainWindowPrivate::toggleDocksShown);
     ac->addAction(QStringLiteral("hide_all_docks"), action);
 
     action = new QAction(i18n("Next Tool View"), this);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_N);
     action->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
     connect(action, &QAction::triggered, this, &MainWindowPrivate::selectNextDock);
     ac->addAction(QStringLiteral("select_next_dock"), action);
 
     action = new QAction(i18n("Previous Tool View"), this);
     ac->setDefaultShortcut(action, Qt::META | Qt::CTRL | Qt::Key_P);
     action->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
     connect(action, &QAction::triggered, this, &MainWindowPrivate::selectPreviousDock);
     ac->addAction(QStringLiteral("select_previous_dock"), action);
 
     action = new KActionMenu(i18n("Tool Views"), this);
     ac->addAction(QStringLiteral("docks_submenu"), action);
 
     idealController = new IdealController(m_mainWindow);
 
     m_leftToolBar = new IdealToolBar(i18n("Left Button Bar"), true, idealController->leftBarWidget, m_mainWindow);
     m_mainWindow->addToolBar(Qt::LeftToolBarArea, m_leftToolBar);
 
     m_rightToolBar = new IdealToolBar(i18n("Right Button Bar"), true, idealController->rightBarWidget, m_mainWindow);
     m_mainWindow->addToolBar(Qt::RightToolBarArea, m_rightToolBar);
 
     m_bottomToolBar = new IdealToolBar(i18n("Bottom Button Bar"), false, idealController->bottomBarWidget, m_mainWindow);
     m_mainWindow->addToolBar(Qt::BottomToolBarArea, m_bottomToolBar);
 
     // adymo: intentionally do not add a toolbar for top buttonbar
     // this doesn't work well with toolbars added via xmlgui
 
     centralWidget = new QWidget;
     QVBoxLayout* layout = new QVBoxLayout(centralWidget);
     centralWidget->setLayout(layout);
     layout->setMargin(0);
     splitterCentralWidget = new QSplitter(centralWidget);
     layout->addWidget(splitterCentralWidget);
     m_mainWindow->setCentralWidget(centralWidget);
 
     connect(idealController,
             &IdealController::dockShown,
             this,
             &MainWindowPrivate::slotDockShown);
 
     connect(idealController,
             &IdealController::widgetResized,
             this,
             &MainWindowPrivate::widgetResized);
 
    connect(idealController, &IdealController::dockBarContextMenuRequested,
             m_mainWindow, &MainWindow::dockBarContextMenuRequested);
 }
 
 
 MainWindowPrivate::~MainWindowPrivate()
 {
     delete m_leftTabbarCornerWidget.data();
     m_leftTabbarCornerWidget.clear();
 }
 
 void MainWindowPrivate::disableConcentrationMode()
 {
     m_concentrationModeAction->setChecked(false);
     restoreConcentrationMode();
 }
 
 void MainWindowPrivate::restoreConcentrationMode()
 {
     const bool concentrationModeOn = m_concentrationModeAction->isChecked();
-    QWidget* cornerWidget = Q_NULLPTR;
+    QWidget* cornerWidget = nullptr;
     if (m_concentrateToolBar) {
         QLayout* l = m_concentrateToolBar->layout();
         QLayoutItem* li = l->takeAt(1); //ensure the cornerWidget isn't destroyed with the toolbar
         if (li) {
             cornerWidget = li->widget();
             delete li;
         }
 
         m_concentrateToolBar->deleteLater();
     }
 
     m_mainWindow->menuBar()->setVisible(!concentrationModeOn);
     m_bottomToolBar->setVisible(!concentrationModeOn);
     m_leftToolBar->setVisible(!concentrationModeOn);
     m_rightToolBar->setVisible(!concentrationModeOn);
     const bool hideToolBar = concentrationModeOn || !Container::configTabBarVisible();
     foreach(Container* c, viewContainers) {
         c->setTabBarHidden(hideToolBar);
     }
 
     if (concentrationModeOn) {
         m_concentrateToolBar = new QToolBar(m_mainWindow);
         m_concentrateToolBar->setObjectName(QStringLiteral("concentrateToolBar"));
         m_concentrateToolBar->addAction(m_concentrationModeAction);
         QWidgetAction *action = new QWidgetAction(this);
 
         action->setDefaultWidget(m_mainWindow->menuBar()->cornerWidget(Qt::TopRightCorner));
         m_concentrateToolBar->addAction(action);
         m_concentrateToolBar->setMovable(false);
 
         m_mainWindow->addToolBar(Qt::TopToolBarArea, m_concentrateToolBar);
         m_mainWindow->menuBar()->setCornerWidget(0, Qt::TopRightCorner);
     } else if (cornerWidget) {
         m_mainWindow->menuBar()->setCornerWidget(cornerWidget, Qt::TopRightCorner);
         cornerWidget->show();
     }
 
     if (concentrationModeOn) {
         m_mainWindow->installEventFilter(this);
     } else {
         m_mainWindow->removeEventFilter(this);
     }
 }
 
 bool MainWindowPrivate::eventFilter(QObject* obj, QEvent* event)
 {
     Q_ASSERT(m_mainWindow == obj);
     if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
         Qt::KeyboardModifiers modifiers = static_cast<QKeyEvent *>(event)->modifiers();
 
         m_mainWindow->menuBar()->setVisible(modifiers == Qt::AltModifier && event->type() == QEvent::KeyPress);
     }
 
     return false;
 }
 
 void MainWindowPrivate::showLeftDock(bool b)
 {
     idealController->showLeftDock(b);
 }
 
 void MainWindowPrivate::showBottomDock(bool b)
 {
     idealController->showBottomDock(b);
 }
 
 void MainWindowPrivate::showRightDock(bool b)
 {
     idealController->showRightDock(b);
 }
 
 void MainWindowPrivate::setBackgroundCentralWidget(QWidget* w)
 {
     delete bgCentralWidget;
     QLayout* l=m_mainWindow->centralWidget()->layout();
     l->addWidget(w);
     bgCentralWidget=w;
     setBackgroundVisible(area->views().isEmpty());
 }
 
 void MainWindowPrivate::setBackgroundVisible(bool v)
 {
     if(!bgCentralWidget)
         return;
 
     bgCentralWidget->setVisible(v);
     splitterCentralWidget->setVisible(!v);
 }
 
 void MainWindowPrivate::focusEditor()
 {
     if (View* view = m_mainWindow->activeView())
         if (view->hasWidget())
             view->widget()->setFocus(Qt::ShortcutFocusReason);
 }
 
 void MainWindowPrivate::toggleDocksShown()
 {
     idealController->toggleDocksShown();
 }
 
 void MainWindowPrivate::selectNextDock()
 {
     idealController->goPrevNextDock(IdealController::NextDock);
 }
 
 void MainWindowPrivate::selectPreviousDock()
 {
     idealController->goPrevNextDock(IdealController::PrevDock);
 }
 
 Area::WalkerMode MainWindowPrivate::IdealToolViewCreator::operator() (View *view, Sublime::Position position)
 {
     if (!d->docks.contains(view))
     {
         d->docks << view;
 
         //add view
         d->idealController->addView(d->positionToDockArea(position), view);
     }
     return Area::ContinueWalker;
 }
 
 Area::WalkerMode MainWindowPrivate::ViewCreator::operator() (AreaIndex *index)
 {
     QSplitter *splitter = d->m_indexSplitters.value(index);
     if (!splitter)
     {
         //no splitter - we shall create it and populate with views
         if (!index->parent())
         {
             qCDebug(SUBLIME) << "reconstructing root area";
             //this is root area
             splitter = d->splitterCentralWidget;
             d->m_indexSplitters[index] = splitter;
             d->centralWidget->layout()->addWidget(splitter);
         }
         else
         {
             if (!d->m_indexSplitters.value(index->parent())) {
                 // can happen in working set code, as that adds a view to a child index first
                 // hence, recursively reconstruct the parent indizes first
                 operator()(index->parent());
             }
             QSplitter *parent = d->m_indexSplitters.value(index->parent());
             splitter = new QSplitter(parent);
             d->m_indexSplitters[index] = splitter;
 
             if(index == index->parent()->first())
                 parent->insertWidget(0, splitter);
             else
                 parent->addWidget(splitter);
         }
         Q_ASSERT(splitter);
     }
 
     if (index->isSplit()) //this is a visible splitter
         splitter->setOrientation(index->orientation());
     else
     {
         Container *container = 0;
 
         while(splitter->count() && qobject_cast<QSplitter*>(splitter->widget(0)))
         {
             // After unsplitting, we might have to remove old splitters
             QWidget* widget = splitter->widget(0);
             qCDebug(SUBLIME) << "deleting" << widget;
             widget->setParent(0);
             delete widget;
         }
 
         if (!splitter->widget(0))
         {
             //we need to create view container
             container = new Container(splitter);
             connect(container, &Container::activateView,
                     d->m_mainWindow, &MainWindow::activateViewAndFocus);
             connect(container, &Container::tabDoubleClicked,
                     d->m_mainWindow, &MainWindow::tabDoubleClicked);
             connect(container, &Container::tabContextMenuRequested,
                     d->m_mainWindow, &MainWindow::tabContextMenuRequested);
             connect(container, &Container::tabToolTipRequested,
                     d->m_mainWindow, &MainWindow::tabToolTipRequested);
             connect(container, static_cast<void(Container::*)(QWidget*)>(&Container::requestClose),
                     d, &MainWindowPrivate::widgetCloseRequest, Qt::QueuedConnection);
             connect(container, &Container::newTabRequested,
                     d->m_mainWindow, &MainWindow::newTabRequested);
             splitter->addWidget(container);
         }
         else
             container = qobject_cast<Container*>(splitter->widget(0));
         container->show();
 
         int position = 0;
         bool hadActiveView = false;
         Sublime::View* activeView = d->activeView;
 
         foreach (View *view, index->views())
         {
             QWidget *widget = view->widget(container);
 
             if (widget)
             {
                 if(!container->hasWidget(widget))
                 {
                     container->addWidget(view, position);
                     d->viewContainers[view] = container;
                     d->widgetToView[widget] = view;
                 }
                 if(activeView == view)
                 {
                     hadActiveView = true;
                     container->setCurrentWidget(widget);
                 }else if(topViews.contains(view) && !hadActiveView)
                     container->setCurrentWidget(widget);
             }
             position++;
         }
     }
     return Area::ContinueWalker;
 }
 
 void MainWindowPrivate::reconstructViews(QList<View*> topViews)
 {
     ViewCreator viewCreator(this, topViews);
     area->walkViews(viewCreator, area->rootIndex());
     setBackgroundVisible(area->views().isEmpty());
 }
 
 void MainWindowPrivate::reconstruct()
 {
     if(m_leftTabbarCornerWidget) {
         m_leftTabbarCornerWidget->hide();
         m_leftTabbarCornerWidget->setParent(0);
     }
 
     idealController->setWidthForArea(Qt::LeftDockWidgetArea, area->thickness(Sublime::Left));
     idealController->setWidthForArea(Qt::BottomDockWidgetArea, area->thickness(Sublime::Bottom));
     idealController->setWidthForArea(Qt::RightDockWidgetArea, area->thickness(Sublime::Right));
 
     IdealToolViewCreator toolViewCreator(this);
     area->walkToolViews(toolViewCreator, Sublime::AllPositions);
 
     reconstructViews();
 
     m_mainWindow->blockSignals(true);
 
     qCDebug(SUBLIME) << "RECONSTRUCT" << area << area->shownToolViews(Sublime::Left);
     foreach (View *view, area->toolViews())
     {
         QString id = view->document()->documentSpecifier();
         if (!id.isEmpty())
         {
             Sublime::Position pos = area->toolViewPosition(view);
             if (area->shownToolViews(pos).contains(id))
                 idealController->raiseView(view, IdealController::GroupWithOtherViews);
         }
     }
     m_mainWindow->blockSignals(false);
 
     setTabBarLeftCornerWidget(m_leftTabbarCornerWidget.data());
 }
 
 void MainWindowPrivate::clearArea()
 {
     if(m_leftTabbarCornerWidget)
         m_leftTabbarCornerWidget->setParent(0);
 
     //reparent toolview widgets to 0 to prevent their deletion together with dockwidgets
     foreach (View *view, area->toolViews())
     {
         // FIXME should we really delete here??
         bool nonDestructive = true;
         idealController->removeView(view, nonDestructive);
 
         if (view->hasWidget())
             view->widget()->setParent(0);
     }
 
     docks.clear();
 
     //reparent all view widgets to 0 to prevent their deletion together with central
     //widget. this reparenting is necessary when switching areas inside the same mainwindow
     foreach (View *view, area->views())
     {
         if (view->hasWidget())
             view->widget()->setParent(0);
     }
     cleanCentralWidget();
     m_mainWindow->setActiveView(0);
     m_indexSplitters.clear();
     area = 0;
     viewContainers.clear();
 
     setTabBarLeftCornerWidget(m_leftTabbarCornerWidget.data());
 }
 
 void MainWindowPrivate::cleanCentralWidget()
 {
     while(splitterCentralWidget->count())
         delete splitterCentralWidget->widget(0);
 
     setBackgroundVisible(true);
 }
 
 struct ShownToolViewFinder {
     ShownToolViewFinder() {}
     Area::WalkerMode operator()(View *v, Sublime::Position /*position*/)
     {
         if (v->hasWidget() && v->widget()->isVisible())
             views << v;
         return Area::ContinueWalker;
     }
     QList<View *> views;
 };
 
 void MainWindowPrivate::slotDockShown(Sublime::View* /*view*/, Sublime::Position pos, bool /*shown*/)
 {
     if (ignoreDockShown)
         return;
 
     ShownToolViewFinder finder;
     m_mainWindow->area()->walkToolViews(finder, pos);
 
     QStringList ids;
     foreach (View *v, finder.views) {
         ids << v->document()->documentSpecifier();
     }
     area->setShownToolViews(pos, ids);
 }
 
 void MainWindowPrivate::viewRemovedInternal(AreaIndex* index, View* view)
 {
     Q_UNUSED(index);
     Q_UNUSED(view);
     setBackgroundVisible(area->views().isEmpty());
 }
 
 void MainWindowPrivate::viewAdded(Sublime::AreaIndex *index, Sublime::View *view)
 {
     if(m_leftTabbarCornerWidget) {
         m_leftTabbarCornerWidget->hide();
         m_leftTabbarCornerWidget->setParent(0);
     }
 
     // Remove container objects in the hierarchy from the parents,
     // because they are not needed anymore, and might lead to broken splitter hierarchy and crashes.
     for(Sublime::AreaIndex* current = index; current; current = current->parent())
     {
         QSplitter *splitter = m_indexSplitters[current];
         if (current->isSplit() && splitter)
         {
             // Also update the orientation
             splitter->setOrientation(current->orientation());
 
             for(int w = 0; w < splitter->count(); ++w)
             {
                 Container *container = qobject_cast<Sublime::Container*>(splitter->widget(w));
                 //we need to remove extra container before reconstruction
                 //first reparent widgets in container so that they are not deleted
                 if(container)
                 {
                     while (container->count())
                     {
                         container->widget(0)->setParent(0);
                     }
                     //and then delete the container
                     delete container;
                 }
             }
         }
     }
 
     ViewCreator viewCreator(this);
     area->walkViews(viewCreator, index);
     emit m_mainWindow->viewAdded( view );
 
     setTabBarLeftCornerWidget(m_leftTabbarCornerWidget.data());
 
     setBackgroundVisible(false);
 }
 
 void Sublime::MainWindowPrivate::raiseToolView(Sublime::View * view)
 {
     idealController->raiseView(view);
 }
 
 void MainWindowPrivate::aboutToRemoveView(Sublime::AreaIndex *index, Sublime::View *view)
 {
     QSplitter *splitter = m_indexSplitters[index];
     if (!splitter)
         return;
 
     qCDebug(SUBLIME) << "index " << index << " root " << area->rootIndex();
     qCDebug(SUBLIME) << "splitter " << splitter << " container " << splitter->widget(0);
     qCDebug(SUBLIME) << "structure: " << index->print() << " whole structure: " << area->rootIndex()->print();
     //find the container for the view and remove the widget
     Container *container = qobject_cast<Container*>(splitter->widget(0));
     if (!container) {
         qWarning() << "Splitter does not have a left widget!";
         return;
     }
 
     emit m_mainWindow->aboutToRemoveView( view );
 
     if (view->widget())
         widgetToView.remove(view->widget());
     viewContainers.remove(view);
 
     const bool wasActive = m_mainWindow->activeView() == view;
     if (container->count() > 1)
     {
         //container is not empty or this is a root index
         //just remove a widget
         if( view->widget() ) {
             container->removeWidget(view->widget());
             view->widget()->setParent(0);
             //activate what is visible currently in the container if the removed view was active
             if (wasActive)
                 return m_mainWindow->setActiveView(container->viewForWidget(container->currentWidget()));
         }
     }
     else
     {
         if(m_leftTabbarCornerWidget) {
             m_leftTabbarCornerWidget->hide();
             m_leftTabbarCornerWidget->setParent(0);
         }
 
         // We've about to remove the last view of this container.  It will
         // be empty, so have to delete it, as well.
 
         // If we have a container, then it should be the only child of
         // the splitter.
         Q_ASSERT(splitter->count() == 1);
         container->removeWidget(view->widget());
 
         if (view->widget())
             view->widget()->setParent(0);
         else
             qWarning() << "View does not have a widget!";
 
         Q_ASSERT(container->count() == 0);
         // We can be called from signal handler of container
         // (which is tab widget), so defer deleting it.
         container->deleteLater();
         container->setParent(0);
 
         /* If we're not at the top level, we get to collapse split views.  */
         if (index->parent())
         {
             /* The splitter used to have container as the only child, now it's
                time to get rid of it.  Make sure deleting splitter does not
                delete container -- per above comment, we'll delete it later.  */
             container->setParent(0);
             m_indexSplitters.remove(index);
             delete splitter;
 
             AreaIndex *parent = index->parent();
             QSplitter *parentSplitter = m_indexSplitters[parent];
 
             AreaIndex *sibling = parent->first() == index ? parent->second() : parent->first();
             QSplitter *siblingSplitter = m_indexSplitters[sibling];
 
             if(siblingSplitter)
             {
                 HoldUpdates du(parentSplitter);
                 //save sizes and orientation of the sibling splitter
                 parentSplitter->setOrientation(siblingSplitter->orientation());
                 QList<int> sizes = siblingSplitter->sizes();
 
                 /* Parent has two children -- 'index' that we've deleted and
                 'sibling'.  We move all children of 'sibling' into parent,
                 and delete 'sibling'.  sibling either contains a single
                 Container instance, or a bunch of further QSplitters.  */
                 while (siblingSplitter->count() > 0)
                 {
                     //reparent contents into parent splitter
                     QWidget *siblingWidget = siblingSplitter->widget(0);
                     siblingWidget->setParent(parentSplitter);
                     parentSplitter->addWidget(siblingWidget);
                 }
 
                 m_indexSplitters.remove(sibling);
                 delete siblingSplitter;
                 parentSplitter->setSizes(sizes);
             }
 
             qCDebug(SUBLIME) << "after deleation " << parent << " has "
                          << parentSplitter->count() << " elements";
 
 
             //find the container somewhere to activate
             Container *containerToActivate = parentSplitter->findChild<Sublime::Container*>();
             //activate the current view there
             if (containerToActivate) {
                 m_mainWindow->setActiveView(containerToActivate->viewForWidget(containerToActivate->currentWidget()));
                 setTabBarLeftCornerWidget(m_leftTabbarCornerWidget.data());
                 return;
             }
         }
     }
 
     setTabBarLeftCornerWidget(m_leftTabbarCornerWidget.data());
     if ( wasActive ) {
         m_mainWindow->setActiveView(0L);
     }
 }
 
 void MainWindowPrivate::toolViewAdded(Sublime::View* /*toolView*/, Sublime::Position position)
 {
     IdealToolViewCreator toolViewCreator(this);
     area->walkToolViews(toolViewCreator, position);
 }
 
 void MainWindowPrivate::aboutToRemoveToolView(Sublime::View *toolView, Sublime::Position /*position*/)
 {
     if (!docks.contains(toolView))
         return;
 
     idealController->removeView(toolView);
     // TODO are Views unique?
     docks.removeAll(toolView);
 }
 
 void MainWindowPrivate::toolViewMoved(
     Sublime::View *toolView, Sublime::Position position)
 {
     if (!docks.contains(toolView))
         return;
 
     idealController->moveView(toolView, positionToDockArea(position));
 }
 
 Qt::DockWidgetArea MainWindowPrivate::positionToDockArea(Position position)
 {
     switch (position)
     {
         case Sublime::Left: return Qt::LeftDockWidgetArea;
         case Sublime::Right: return Qt::RightDockWidgetArea;
         case Sublime::Bottom: return Qt::BottomDockWidgetArea;
         case Sublime::Top: return Qt::TopDockWidgetArea;
         default: return Qt::LeftDockWidgetArea;
     }
 }
 
 void MainWindowPrivate::switchToArea(QAction *action)
 {
     qCDebug(SUBLIME) << "for" << action;
     controller->showArea(m_actionAreas.value(action), m_mainWindow);
 }
 
 void MainWindowPrivate::updateAreaSwitcher(Sublime::Area *area)
 {
     QAction* action = m_areaActions.value(area);
     if (action)
         action->setChecked(true);
 }
 
 void MainWindowPrivate::activateFirstVisibleView()
 {
     QList<Sublime::View*> views = area->views();
     if (views.count() > 0)
         m_mainWindow->activateView(views.first());
 }
 
 void MainWindowPrivate::widgetResized(Qt::DockWidgetArea /*dockArea*/, int /*thickness*/)
 {
     //TODO: adymo: remove all thickness business
 }
 
 void MainWindowPrivate::widgetCloseRequest(QWidget* widget)
 {
     if (View *view = widgetToView.value(widget))
     {
         area->closeView(view);
     }
 }
 
 
 void MainWindowPrivate::setTabBarLeftCornerWidget(QWidget* widget)
 {
     if(widget != m_leftTabbarCornerWidget.data()) {
         delete m_leftTabbarCornerWidget.data();
         m_leftTabbarCornerWidget.clear();
     }
     m_leftTabbarCornerWidget = widget;
 
     if(!widget || !area || viewContainers.isEmpty())
         return;
 
     AreaIndex* putToIndex = area->rootIndex();
     QSplitter* splitter = m_indexSplitters[putToIndex];
     while(putToIndex->isSplit()) {
         putToIndex = putToIndex->first();
         splitter = m_indexSplitters[putToIndex];
     }
 
 //     Q_ASSERT(splitter || putToIndex == area->rootIndex());
 
     Container* c = 0;
     if(splitter) {
         c = qobject_cast<Container*>(splitter->widget(0));
     }else{
         c = viewContainers.values()[0];
     }
     Q_ASSERT(c);
 
     c->setLeftCornerWidget(widget);
 }
 
 }
 
 #include "mainwindow_p.moc"
 #include "moc_mainwindow_p.cpp"
 
diff --git a/util/environmentgrouplist.cpp b/util/environmentgrouplist.cpp
index 0358070c6..e2e100b78 100644
--- a/util/environmentgrouplist.cpp
+++ b/util/environmentgrouplist.cpp
@@ -1,203 +1,223 @@
 /* This file is part of KDevelop
 Copyright 2007 Andreas Pakulat <apaku@gmx.de>
 
 This library 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 library 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #include "environmentgrouplist.h"
 
 #include <QMap>
 #include <QStringList>
 #include <QString>
 
 #include <KConfigGroup>
 
+#include <QRegularExpression>
+#include <QProcessEnvironment>
 
 namespace KDevelop {
 class EnvironmentGroupListPrivate
 {
 public:
     QMap<QString, QMap<QString,QString> > m_groups;
     QString m_defaultGroup;
 };
 }
 
 using namespace KDevelop;
 
 namespace {
 
 namespace Strings {
 inline QString defaultEnvGroupKey() { return QStringLiteral("Default Environment Group"); }
 inline QString envGroup() { return QStringLiteral("Environment Settings"); }
 inline QString groupListKey() { return QStringLiteral("Group List"); }
 inline QString defaultGroup() { return QStringLiteral("default"); }
 }
 
 void decode( KConfig* config, EnvironmentGroupListPrivate* d )
 {
     KConfigGroup cfg( config, Strings::envGroup() );
     d->m_defaultGroup = cfg.readEntry( Strings::defaultEnvGroupKey(), Strings::defaultGroup() );
     QStringList grouplist = cfg.readEntry( Strings::groupListKey(), QStringList{Strings::defaultGroup()} );
     foreach( const QString &envgrpname, grouplist )
     {
         KConfigGroup envgrp( &cfg, envgrpname );
         QMap<QString,QString> variables;
         foreach( const QString &varname, envgrp.keyList() )
         {
             variables[varname] = envgrp.readEntry( varname, QString() );
         }
         d->m_groups.insert( envgrpname, variables );
     }
 }
 
 void encode( KConfig* config, EnvironmentGroupListPrivate* d )
 {
     KConfigGroup cfg( config, Strings::envGroup() );
     cfg.writeEntry( Strings::defaultEnvGroupKey(), d->m_defaultGroup );
     cfg.writeEntry( Strings::groupListKey(), d->m_groups.keys() );
     foreach( const QString &group, cfg.groupList() )
     {
         if( !d->m_groups.keys().contains( group ) )
         {
             cfg.deleteGroup( group );
         }
     }
     foreach( const QString &group, d->m_groups.keys() )
     {
         KConfigGroup envgrp( &cfg, group );
         envgrp.deleteGroup();
         foreach( const QString &var, d->m_groups[group].keys() )
         {
             envgrp.writeEntry( var, d->m_groups[group][var] );
         }
     }
     cfg.sync();
 }
 
 }
 
 EnvironmentGroupList::EnvironmentGroupList( const EnvironmentGroupList& rhs )
     : d( new EnvironmentGroupListPrivate( *rhs.d ) )
 {
 }
 
 EnvironmentGroupList& EnvironmentGroupList::operator=( const EnvironmentGroupList& rhs )
 {
     *d = *rhs.d;
     return *this;
 }
 
 EnvironmentGroupList::EnvironmentGroupList( KSharedConfigPtr config )
     : d( new EnvironmentGroupListPrivate )
 {
     decode( config.data(), d );
 }
 
 EnvironmentGroupList::EnvironmentGroupList( KConfig* config )
     : d( new EnvironmentGroupListPrivate )
 {
     decode( config, d );
 }
 
 EnvironmentGroupList::~EnvironmentGroupList()
 {
     delete d;
 }
 
 const QMap<QString, QString> EnvironmentGroupList::variables( const QString& group ) const
 {
     return d->m_groups[group.isEmpty() ? d->m_defaultGroup : group];
 }
 
 QMap<QString, QString>& EnvironmentGroupList::variables( const QString& group )
 {
     return d->m_groups[group.isEmpty() ? d->m_defaultGroup : group];
 }
 
 
 QString EnvironmentGroupList::defaultGroup() const
 {
     return d->m_defaultGroup;
 }
 
 void EnvironmentGroupList::setDefaultGroup( const QString& group )
 {
     if( group.isEmpty() ) {
         return;
     }
 
     if( d->m_groups.contains( group ) )
     {
         d->m_defaultGroup = group;
     }
 }
 
 void EnvironmentGroupList::saveSettings( KConfig* config ) const
 {
     encode( config, d );
     config->sync();
 }
 
 void EnvironmentGroupList::loadSettings( KConfig* config )
 {
     d->m_groups.clear();
     decode( config, d );
 }
 
 QStringList EnvironmentGroupList::groups() const
 {
     return d->m_groups.keys();
 }
 
 void EnvironmentGroupList::removeGroup( const QString& group )
 {
     d->m_groups.remove( group );
 }
 
 EnvironmentGroupList::EnvironmentGroupList()
     : d( new EnvironmentGroupListPrivate )
 {
 }
 
 QStringList EnvironmentGroupList::createEnvironment( const QString & group, const QStringList & defaultEnvironment ) const
 {
     QMap<QString, QString> retMap;
     foreach( const QString &line, defaultEnvironment )
     {
         QString varName = line.section( '=', 0, 0 );
         QString varValue = line.section( '=', 1 );
         retMap.insert( varName, varValue );
     }
 
     if( !group.isEmpty() ) {
       QMap<QString, QString> userMap = variables(group);
 
       for( QMap<QString, QString>::const_iterator it = userMap.constBegin();
           it != userMap.constEnd(); ++it )
       {
           retMap.insert( it.key(), it.value() );
       }
     }
 
     QStringList env;
     for( QMap<QString, QString>::const_iterator it = retMap.constBegin();
         it != retMap.constEnd(); ++it )
     {
         env << it.key() + '=' + it.value();
     }
 
     return env;
 }
+
+void KDevelop::expandVariables(QMap<QString, QString>& variables, const QProcessEnvironment& environment)
+{
+    QRegularExpression rVar("(?<!\\\\)(\\$\\w+)");
+    QRegularExpression rNotVar("\\\\\\$");
+    for (auto it = variables.begin(); it != variables.end(); ++it) {
+        QRegularExpressionMatch m;
+        while ((m=rVar.match(it.value())).hasMatch()) {
+            if (environment.contains(m.captured(1).midRef(1).toString())) {
+                it.value().replace(m.capturedStart(0), m.capturedLength(0), environment.value(m.captured(0).midRef(1).toString()));
+            } else {
+                //TODO: an warning
+                it.value().replace(m.capturedStart(0), m.capturedLength(0), "");
+            }
+        }
+        it.value().replace(rNotVar,"$");
+    }
+}
diff --git a/util/environmentgrouplist.h b/util/environmentgrouplist.h
index af1c0e7ac..9e26a1b55 100644
--- a/util/environmentgrouplist.h
+++ b/util/environmentgrouplist.h
@@ -1,145 +1,148 @@
 /* This file is part of KDevelop
 Copyright 2007 Andreas Pakulat <apaku@gmx.de>
 
 This library 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 library 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
 #ifndef KDEVPLATFORM_ENVIRONMENTGROUPLIST_H
 #define KDEVPLATFORM_ENVIRONMENTGROUPLIST_H
 
 #include "utilexport.h"
 
 #include <KSharedConfig>
 
+class QProcessEnvironment;
 class KConfig;
 template <typename T1, typename T2> class QMap;
 class QString;
 class QStringList;
 
 namespace KDevelop
 {
 
 /**
  * This class manages a list of environment groups, each group containing a number
  * of environment variables and their values.
  *
  * The class is constructed from a KConfig object for easy usage in the plugins.
  *
  * The methods to change the environments is protected to disallow access to those methods
  * from plugins, only the environment widget is allowed to change them.
  *
  * Example Usage
  * \code
  *   KSharedConfigPtr config = KSharedConfig::openConfig();
  *   EnvironmentGroupList env(config);
  *   KConfigGroup cfg(config, "QMake Builder");
  *   QMap<QString,QString> myenvVars = env.variables( cfg.readEntry("QMake Environment") );
  * \endcode
  *
  * Two entries are used by this class:
  * "Default Environment Group" and "Environment Variables".
  *
  * "Default Environment Variables" stores the default group that should be used if the
  * user didn't select a group via a plugins configuration dialog.
  *
  * "Environment Variables" entry stores the actual list of
  * <groupname%varname=varvalue>. The groupname can't contain '%' or '='.
  * For example, suppose that two configuration, say "release" and "debug" exist.
  * Then the actual contents of .kdev4 project file will be
  *
  * \code
  * [Environment Settings]
  * Default Environment Group=debug
  * Environment Variables=debug_PATH=/home/kde-devel/usr/bin,release_PATH=/usr/bin
  * \endcode
  *
  */
 class KDEVPLATFORMUTIL_EXPORT EnvironmentGroupList
 {
 public:
     EnvironmentGroupList( const EnvironmentGroupList& rhs );
     EnvironmentGroupList& operator=( const EnvironmentGroupList& rhs );
 
     /**
      * Creates an a list of EnvironmentGroups from a KConfig object
      * @param config the KConfig object to read the environment groups from
      */
     explicit EnvironmentGroupList( KSharedConfigPtr config );
     explicit EnvironmentGroupList( KConfig* config );
     ~EnvironmentGroupList();
 
     /**
      * Creates a merged environment between the defaults specified by
      * \a defaultEnvironment and those saved in \a group
      */
     QStringList createEnvironment(const QString& group, const QStringList& defaultEnvironment ) const;
 
     /**
      * returns the variables that are set for a given group.
      * This function provides read-only access to the environment
      * @param group  the name of the group for which the environment should be returned
      * @return a map containing the environment variables for this group, or an empty map if the group doesn't exist in this list
      */
     const QMap<QString, QString> variables( const QString& group ) const;
 
     /**
      * returns the default group
      * The default group should be used by plugins unless the user chooses a different group
      * @return the name of the default group, defaults to "default"
      */
     QString defaultGroup() const;
 
     /**
      * Fetch the list of known groups from the list
      * @return the list of groups
      */
     QStringList groups() const;
 
 protected:
     EnvironmentGroupList();
     /**
      * returns the variables that are set for a given group.
      * This function provides write access to the environment, so new variables can be inserted, existing ones changed or deleted
      *
      * If a non-existing group is specified this returns a new empty map and that way this function can be used to add a new group
      * to the list of environment groups
      * @param group  the name of the group for which the environment should be returned
      * @return a map containing the environment variables for this group, or an empty map if the group doesn't exist in this list
      */
     QMap<QString, QString>& variables( const QString& group );
 
     /**
      * Changes the default group.
      * @param group a new groupname, if a group of this name doesn't exist the default group is not changed
      */
     void setDefaultGroup( const QString& group );
 
     /**
      * Stores the environment groups in this list to the given KConfig object
      * @param config a KConfig object to which the environment settings should be stored
      */
     void saveSettings( KConfig* config ) const;
 
     void loadSettings( KConfig* config );
     void removeGroup( const QString& group );
 private:
     class EnvironmentGroupListPrivate* const d;
 
 };
 
+KDEVPLATFORMUTIL_EXPORT void expandVariables(QMap<QString, QString>& variables, const QProcessEnvironment& environment);
+
 }
 
 #endif
diff --git a/util/tests/CMakeLists.txt b/util/tests/CMakeLists.txt
index bdf9c2ae0..fdff47a2d 100644
--- a/util/tests/CMakeLists.txt
+++ b/util/tests/CMakeLists.txt
@@ -1,20 +1,23 @@
 ecm_add_test(test_embeddedfreetree.cpp
     LINK_LIBRARIES KF5::TextEditor Qt5::Test KDev::Language KDev::Tests)
 
 ecm_add_test(test_kdevvarlengtharray.cpp
     LINK_LIBRARIES Qt5::Test)
 
 ecm_add_test(test_objectlist.cpp
     LINK_LIBRARIES Qt5::Test KDev::Util)
 
 ecm_add_test(test_stringhandler.cpp
     LINK_LIBRARIES Qt5::Test KDev::Util)
 
 ecm_add_test(test_path.cpp
     LINK_LIBRARIES Qt5::Test KF5::KIOCore KDev::Tests KDev::Util)
 
 ecm_add_test(test_foregroundlock.cpp
     LINK_LIBRARIES Qt5::Test KDev::Util)
 
 ecm_add_test(test_executecompositejob.cpp
     LINK_LIBRARIES Qt5::Test KDev::Util)
+
+ecm_add_test(test_environment.cpp
+    LINK_LIBRARIES Qt5::Test KDev::Util)
diff --git a/util/tests/test_environment.cpp b/util/tests/test_environment.cpp
new file mode 100644
index 000000000..c20200dae
--- /dev/null
+++ b/util/tests/test_environment.cpp
@@ -0,0 +1,81 @@
+/*
+ * This file is part of KDevelop
+ *
+ * Copyright 2015 Artur Puzio <cytadela88@gmail.com>
+ *
+ * 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 "test_environment.h"
+
+#include "util/environmentgrouplist.h"
+
+#include <QtTest>
+
+QTEST_MAIN(TestEnvironment);
+
+using ProcEnv = QMap<QString,QString>;
+
+void TestEnvironment::testExpandVariables_data()
+{
+    QTest::addColumn<ProcEnv>("env");
+    QTest::addColumn<ProcEnv>("expectedEnv");
+
+    QTest::newRow("no variables") << ProcEnv({}) << ProcEnv({});
+    QTest::newRow("simple variables") << ProcEnv{
+        {"VAR1","data"},
+        {"Var2","some other data"}
+    } << ProcEnv({
+        {"VAR1","data"},
+        {"Var2","some other data"}
+    });
+    QTest::newRow("PATH append and prepend")    << ProcEnv({
+        {"PATH","/home/usr/bin:$PATH:/home/user/folder"}
+    }) << ProcEnv({
+        {"PATH", "/home/usr/bin:/bin:/usr/bin:/home/user/folder"}
+    });
+    QTest::newRow("\\$VAR") << ProcEnv({
+        {"MY_VAR","\\$PATH something \\$HOME"}
+    }) << ProcEnv({
+        {"MY_VAR","$PATH something $HOME"}
+    });
+    QTest::newRow("spaces, \\$VAR after $VAR") << ProcEnv({
+        {"MY_VAR","$PATH:$HOME something \\$HOME"}
+    }) << ProcEnv({
+        {"MY_VAR","/bin:/usr/bin:/home/tom something $HOME"}
+    });
+    QTest::newRow("VAR2=$VAR1") << ProcEnv({
+        {"VAR1","/some/path"},{"VAR2","$VAR1"}
+    }) << ProcEnv({
+        {"VAR1","/some/path"},{"VAR2",""}
+    });
+}
+
+void TestEnvironment::testExpandVariables()
+{
+    QFETCH(ProcEnv, env);
+    QFETCH(ProcEnv, expectedEnv);
+
+    QProcessEnvironment fakeSysEnv;
+    fakeSysEnv.insert("PATH","/bin:/usr/bin");
+    fakeSysEnv.insert("HOME","/home/tom");
+
+    KDevelop::expandVariables(env, fakeSysEnv);
+
+    for (auto it = expectedEnv.cbegin(); it!= expectedEnv.cend(); ++it) {
+        QCOMPARE(env.value(it.key()), it.value());
+    }
+}
diff --git a/util/tests/test_environment.h b/util/tests/test_environment.h
new file mode 100644
index 000000000..ce7b07e4a
--- /dev/null
+++ b/util/tests/test_environment.h
@@ -0,0 +1,35 @@
+/*
+ * This file is part of KDevelop
+ *
+ * Copyright 2015 Artur Puzio <cytadela88@gmail.com>
+ *
+ * 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 TESTENVIRONMENT_H
+#define TESTENVIRONMENT_H
+
+#include <QObject>
+
+class TestEnvironment : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void testExpandVariables_data();
+    void testExpandVariables();
+};
+
+#endif // TESTENVIRONMENT_H