diff --git a/debuggers/common/mibreakpointcontroller.cpp b/debuggers/common/mibreakpointcontroller.cpp
index 0552e22f2f..b6e021b299 100644
--- a/debuggers/common/mibreakpointcontroller.cpp
+++ b/debuggers/common/mibreakpointcontroller.cpp
@@ -1,759 +1,759 @@
 /* This file is part of the KDE project
    Copyright (C) 2002 Matthias Hoelzer-Kluepfel <hoelzer@kde.org>
    Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
    Copyright (C) 2006, 2008 Vladimir Prus <ghost@cs.msu.su>
    Copyright (C) 2007 Hamish Rodda <rodda@kde.org>
    Copyright (C) 2009 Niko Sams <niko.sams@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., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 
 #include "mibreakpointcontroller.h"
 
 #include "debuglog.h"
 #include "midebugsession.h"
 #include "mi/micommand.h"
 #include "stringhelpers.h"
 
 #include <debugger/breakpoint/breakpoint.h>
 #include <debugger/breakpoint/breakpointmodel.h>
 
 #include <KLocalizedString>
 
 using namespace KDevMI;
 using namespace KDevMI::MI;
 using namespace KDevelop;
 
 struct MIBreakpointController::Handler : public MICommandHandler
 {
     Handler(MIBreakpointController* controller, const BreakpointDataPtr& b,
             BreakpointModel::ColumnFlags columns)
         : controller(controller)
         , breakpoint(b)
         , columns(columns)
     {
         breakpoint->sent |= columns;
         breakpoint->dirty &= ~columns;
     }
 
     void handle(const ResultRecord& r) override
     {
         breakpoint->sent &= ~columns;
 
         if (r.reason == QLatin1String("error")) {
             breakpoint->errors |= columns;
 
             int row = controller->breakpointRow(breakpoint);
             if (row >= 0) {
                 controller->updateErrorText(row, r[QStringLiteral("msg")].literal());
-                qWarning() << r[QStringLiteral("msg")].literal();
+                qCWarning(DEBUGGERCOMMON) << r[QStringLiteral("msg")].literal();
             }
         } else {
             if (breakpoint->errors & columns) {
                 breakpoint->errors &= ~columns;
 
                 if (breakpoint->errors) {
                     // Since at least one error column cleared, it's possible that any remaining
                     // error bits were collateral damage; try resending the corresponding columns
                     // to see whether errors remain.
                     breakpoint->dirty |= (breakpoint->errors & ~breakpoint->sent);
                 }
             }
         }
     }
 
     bool handlesError() override
     {
         return true;
     }
 
     MIBreakpointController* controller;
     BreakpointDataPtr breakpoint;
     BreakpointModel::ColumnFlags columns;
 };
 
 struct MIBreakpointController::UpdateHandler : public MIBreakpointController::Handler
 {
     UpdateHandler(MIBreakpointController* c, const BreakpointDataPtr& b,
                   BreakpointModel::ColumnFlags columns)
         : Handler(c, b, columns) {}
 
     void handle(const ResultRecord &r) override
     {
         Handler::handle(r);
 
         int row = controller->breakpointRow(breakpoint);
         if (row >= 0) {
             // Note: send further updates even if we got an error; who knows: perhaps
             // these additional updates will "unstuck" the error condition.
             if (breakpoint->sent == 0 && breakpoint->dirty != 0) {
                 controller->sendUpdates(row);
             }
             controller->recalculateState(row);
         }
     }
 };
 
 struct MIBreakpointController::InsertedHandler : public MIBreakpointController::Handler
 {
     InsertedHandler(MIBreakpointController* c, const BreakpointDataPtr& b,
                     BreakpointModel::ColumnFlags columns)
         : Handler(c, b, columns) {}
 
     void handle(const ResultRecord &r) override
     {
         Handler::handle(r);
 
         int row = controller->breakpointRow(breakpoint);
 
         if (r.reason != QLatin1String("error")) {
             QString bkptKind;
             for (auto kind : {"bkpt", "wpt", "hw-rwpt", "hw-awpt"}) {
                 if (r.hasField(kind)) {
                     bkptKind = kind;
                     break;
                 }
             }
             if (bkptKind.isEmpty()) {
-                qWarning() << "Gdb sent unknown breakpoint kind";
+                qCWarning(DEBUGGERCOMMON) << "Gdb sent unknown breakpoint kind";
                 return;
             }
 
             const Value& miBkpt = r[bkptKind];
 
             breakpoint->debuggerId = miBkpt[QStringLiteral("number")].toInt();
 
             if (row >= 0) {
                 controller->updateFromDebugger(row, miBkpt);
                 if (breakpoint->dirty != 0)
                     controller->sendUpdates(row);
             } else {
                 // breakpoint was deleted while insertion was in flight
                 controller->debugSession()->addCommand(BreakDelete,
                                                        QString::number(breakpoint->debuggerId),
                                                        CmdImmediately);
             }
         }
 
         if (row >= 0) {
             controller->recalculateState(row);
         }
     }
 };
 
 struct MIBreakpointController::DeleteHandler : MIBreakpointController::Handler {
     DeleteHandler(MIBreakpointController* c, const BreakpointDataPtr& b)
         : Handler(c, b, nullptr) {}
 
     void handle(const ResultRecord&) override
     {
         controller->m_pendingDeleted.removeAll(breakpoint);
     }
 };
 
 struct MIBreakpointController::IgnoreChanges {
     explicit IgnoreChanges(MIBreakpointController& controller)
         : controller(controller)
     {
         ++controller.m_ignoreChanges;
     }
 
     ~IgnoreChanges()
     {
         --controller.m_ignoreChanges;
     }
 
     MIBreakpointController& controller;
 };
 
 MIBreakpointController::MIBreakpointController(MIDebugSession * parent)
     : IBreakpointController(parent)
 {
     Q_ASSERT(parent);
     connect(parent, &MIDebugSession::inferiorStopped,
             this, &MIBreakpointController::programStopped);
 
     int numBreakpoints = breakpointModel()->breakpoints().size();
     for (int row = 0; row < numBreakpoints; ++row)
         breakpointAdded(row);
 }
 
 MIDebugSession *MIBreakpointController::debugSession() const
 {
     Q_ASSERT(QObject::parent());
     return static_cast<MIDebugSession *>(const_cast<QObject*>(QObject::parent()));
 }
 
 int MIBreakpointController::breakpointRow(const BreakpointDataPtr& breakpoint)
 {
     return m_breakpoints.indexOf(breakpoint);
 }
 
 void MIBreakpointController::setDeleteDuplicateBreakpoints(bool enable)
 {
     m_deleteDuplicateBreakpoints = enable;
 }
 
 void MIBreakpointController::initSendBreakpoints()
 {
     for (int row = 0; row < m_breakpoints.size(); ++row) {
         BreakpointDataPtr breakpoint = m_breakpoints[row];
         if (breakpoint->debuggerId < 0 && breakpoint->sent == 0) {
             createBreakpoint(row);
         }
     }
 }
 
 void MIBreakpointController::breakpointAdded(int row)
 {
     if (m_ignoreChanges > 0)
         return;
 
     auto breakpoint = BreakpointDataPtr::create();
     m_breakpoints.insert(row, breakpoint);
 
     const Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row);
     if (!modelBreakpoint->enabled())
         breakpoint->dirty |= BreakpointModel::EnableColumnFlag;
     if (!modelBreakpoint->condition().isEmpty())
         breakpoint->dirty |= BreakpointModel::ConditionColumnFlag;
     if (modelBreakpoint->ignoreHits() != 0)
         breakpoint->dirty |= BreakpointModel::IgnoreHitsColumnFlag;
     if (!modelBreakpoint->address().isEmpty())
         breakpoint->dirty |= BreakpointModel::LocationColumnFlag;
 
     createBreakpoint(row);
 }
 
 void MIBreakpointController::breakpointModelChanged(int row, BreakpointModel::ColumnFlags columns)
 {
     if (m_ignoreChanges > 0)
         return;
 
     BreakpointDataPtr breakpoint = m_breakpoints.at(row);
     breakpoint->dirty |= columns &
         (BreakpointModel::EnableColumnFlag | BreakpointModel::LocationColumnFlag |
          BreakpointModel::ConditionColumnFlag | BreakpointModel::IgnoreHitsColumnFlag);
 
     if (breakpoint->sent != 0) {
         // Throttle the amount of commands we send to GDB; the response handler of currently
         // in-flight commands will take care of sending the update.
         // This also prevents us from sending updates while a break-create command is in-flight.
         return;
     }
 
     if (breakpoint->debuggerId < 0) {
         createBreakpoint(row);
     } else {
         sendUpdates(row);
     }
 }
 
 void MIBreakpointController::breakpointAboutToBeDeleted(int row)
 {
     if (m_ignoreChanges > 0)
         return;
 
     BreakpointDataPtr breakpoint = m_breakpoints.at(row);
     m_breakpoints.removeAt(row);
 
     if (breakpoint->debuggerId < 0) {
         // Two possibilities:
         //  (1) Breakpoint has never been sent to GDB, so we're done
         //  (2) Breakpoint has been sent to GDB, but we haven't received
         //      the response yet; the response handler will delete the
         //      breakpoint.
         return;
     }
 
     if (debugSession()->debuggerStateIsOn(s_dbgNotStarted))
         return;
 
     debugSession()->addCommand(
             BreakDelete, QString::number(breakpoint->debuggerId),
             new DeleteHandler(this, breakpoint), CmdImmediately);
     m_pendingDeleted << breakpoint;
 }
 
 // Note: despite the name, this is in fact session state changed.
 void MIBreakpointController::debuggerStateChanged(IDebugSession::DebuggerState state)
 {
     IgnoreChanges ignoreChanges(*this);
     if (state == IDebugSession::EndedState ||
         state == IDebugSession::NotStartedState) {
         for (int row = 0; row < m_breakpoints.size(); ++row) {
             updateState(row, Breakpoint::NotStartedState);
         }
     } else if (state == IDebugSession::StartingState) {
         for (int row = 0; row < m_breakpoints.size(); ++row) {
             updateState(row, Breakpoint::DirtyState);
         }
     }
 }
 
 void MIBreakpointController::createBreakpoint(int row)
 {
     if (debugSession()->debuggerStateIsOn(s_dbgNotStarted))
         return;
 
     BreakpointDataPtr breakpoint = m_breakpoints.at(row);
     Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row);
 
     Q_ASSERT(breakpoint->debuggerId < 0 && breakpoint->sent == 0);
 
     if (modelBreakpoint->location().isEmpty())
         return;
 
     if (modelBreakpoint->kind() == Breakpoint::CodeBreakpoint) {
         QString location;
         if (modelBreakpoint->line() != -1) {
             location = QStringLiteral("%0:%1")
                 .arg(modelBreakpoint->url().url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash))
                 .arg(modelBreakpoint->line() + 1);
         } else {
             location = modelBreakpoint->location();
         }
 
         if (location == QLatin1String("catch throw")) {
             location = QStringLiteral("exception throw");
         }
 
         // Note: We rely on '-f' to be automatically added by the MICommand logic
         QString arguments;
         if (!modelBreakpoint->enabled())
             arguments += QLatin1String("-d ");
         if (!modelBreakpoint->condition().isEmpty())
             arguments += QStringLiteral("-c %0 ").arg(Utils::quoteExpression(modelBreakpoint->condition()));
         if (modelBreakpoint->ignoreHits() != 0)
             arguments += QStringLiteral("-i %0 ").arg(modelBreakpoint->ignoreHits());
         arguments += Utils::quoteExpression(location);
 
         BreakpointModel::ColumnFlags sent =
             BreakpointModel::EnableColumnFlag |
             BreakpointModel::ConditionColumnFlag |
             BreakpointModel::IgnoreHitsColumnFlag |
             BreakpointModel::LocationColumnFlag;
         debugSession()->addCommand(BreakInsert, arguments,
                                    new InsertedHandler(this, breakpoint, sent),
                                    CmdImmediately);
     } else {
         QString opt;
         if (modelBreakpoint->kind() == Breakpoint::ReadBreakpoint)
             opt = QStringLiteral("-r ");
         else if (modelBreakpoint->kind() == Breakpoint::AccessBreakpoint)
             opt = QStringLiteral("-a ");
 
         debugSession()->addCommand(BreakWatch,
                                    opt + Utils::quoteExpression(modelBreakpoint->location()),
                                    new InsertedHandler(this, breakpoint,
                                                        BreakpointModel::LocationColumnFlag),
                                    CmdImmediately);
     }
 
     recalculateState(row);
 }
 
 void MIBreakpointController::sendUpdates(int row)
 {
     if (debugSession()->debuggerStateIsOn(s_dbgNotStarted))
         return;
 
     BreakpointDataPtr breakpoint = m_breakpoints.at(row);
     Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row);
 
     Q_ASSERT(breakpoint->debuggerId >= 0 && breakpoint->sent == 0);
 
     if (breakpoint->dirty & BreakpointModel::LocationColumnFlag) {
         // Gdb considers locations as fixed, so delete and re-create the breakpoint
         debugSession()->addCommand(BreakDelete,
                                    QString::number(breakpoint->debuggerId), CmdImmediately);
         breakpoint->debuggerId = -1;
         createBreakpoint(row);
         return;
     }
 
     if (breakpoint->dirty & BreakpointModel::EnableColumnFlag) {
         debugSession()->addCommand(modelBreakpoint->enabled() ? BreakEnable : BreakDisable,
                                    QString::number(breakpoint->debuggerId),
                                    new UpdateHandler(this, breakpoint,
                                                      BreakpointModel::EnableColumnFlag),
                                    CmdImmediately);
     }
     if (breakpoint->dirty & BreakpointModel::IgnoreHitsColumnFlag) {
         debugSession()->addCommand(BreakAfter,
                                    QStringLiteral("%0 %1").arg(breakpoint->debuggerId)
                                                    .arg(modelBreakpoint->ignoreHits()),
                                    new UpdateHandler(this, breakpoint,
                                                      BreakpointModel::IgnoreHitsColumnFlag),
                                    CmdImmediately);
     }
     if (breakpoint->dirty & BreakpointModel::ConditionColumnFlag) {
         debugSession()->addCommand(BreakCondition,
                                    QStringLiteral("%0 %1").arg(breakpoint->debuggerId)
                                                    .arg(modelBreakpoint->condition()),
                                    new UpdateHandler(this, breakpoint,
                                                      BreakpointModel::ConditionColumnFlag),
                                    CmdImmediately);
     }
 
     recalculateState(row);
 }
 
 void MIBreakpointController::recalculateState(int row)
 {
     BreakpointDataPtr breakpoint = m_breakpoints.at(row);
 
     if (breakpoint->errors == 0)
         updateErrorText(row, QString());
 
     Breakpoint::BreakpointState newState = Breakpoint::NotStartedState;
     if (debugSession()->state() != IDebugSession::EndedState &&
         debugSession()->state() != IDebugSession::NotStartedState) {
         if (!debugSession()->debuggerStateIsOn(s_dbgNotStarted)) {
             if (breakpoint->dirty == 0 && breakpoint->sent == 0) {
                 if (breakpoint->pending) {
                     newState = Breakpoint::PendingState;
                 } else {
                     newState = Breakpoint::CleanState;
                 }
             } else {
                 newState = Breakpoint::DirtyState;
             }
         }
     }
 
     updateState(row, newState);
 }
 
 int MIBreakpointController::rowFromDebuggerId(int gdbId) const
 {
     for (int row = 0; row < m_breakpoints.size(); ++row) {
         if (gdbId == m_breakpoints[row]->debuggerId)
             return row;
     }
     return -1;
 }
 
 void MIBreakpointController::notifyBreakpointCreated(const AsyncRecord& r)
 {
     const Value& miBkpt = r[QStringLiteral("bkpt")];
 
     // Breakpoints with multiple locations are represented by a parent breakpoint (e.g. 1)
     // and multiple child breakpoints (e.g. 1.1, 1.2, 1.3, ...).
     // We ignore the child breakpoints here in the current implementation; this can lead to dubious
     // results in the UI when breakpoints are marked in document views (e.g. when a breakpoint
     // applies to multiple overloads of a C++ function simultaneously) and in disassembly
     // (e.g. when a breakpoint is set in an inlined functions).
     if (miBkpt[QStringLiteral("number")].literal().contains('.'))
         return;
 
     createFromDebugger(miBkpt);
 }
 
 void MIBreakpointController::notifyBreakpointModified(const AsyncRecord& r)
 {
     const Value& miBkpt = r[QStringLiteral("bkpt")];
     const int gdbId = miBkpt[QStringLiteral("number")].toInt();
     const int row = rowFromDebuggerId(gdbId);
 
     if (row < 0) {
         for (const auto& breakpoint : m_pendingDeleted) {
             if (breakpoint->debuggerId == gdbId) {
                 // Received a modification of a breakpoint whose deletion is currently
                 // in-flight; simply ignore it.
                 return;
             }
         }
 
         qCWarning(DEBUGGERCOMMON) << "Received a modification of an unknown breakpoint";
         createFromDebugger(miBkpt);
     } else {
         updateFromDebugger(row, miBkpt);
     }
 }
 
 void MIBreakpointController::notifyBreakpointDeleted(const AsyncRecord& r)
 {
     const int gdbId = r[QStringLiteral("id")].toInt();
     const int row = rowFromDebuggerId(gdbId);
 
     if (row < 0) {
         // The user may also have deleted the breakpoint via the UI simultaneously
         return;
     }
 
     IgnoreChanges ignoreChanges(*this);
     breakpointModel()->removeRow(row);
     m_breakpoints.removeAt(row);
 }
 
 void MIBreakpointController::createFromDebugger(const Value& miBkpt)
 {
     const QString type = miBkpt[QStringLiteral("type")].literal();
     Breakpoint::BreakpointKind gdbKind;
     if (type == QLatin1String("breakpoint")) {
         gdbKind = Breakpoint::CodeBreakpoint;
     } else if (type == QLatin1String("watchpoint") || type == QLatin1String("hw watchpoint")) {
         gdbKind = Breakpoint::WriteBreakpoint;
     } else if (type == QLatin1String("read watchpoint")) {
         gdbKind = Breakpoint::ReadBreakpoint;
     } else if (type == QLatin1String("acc watchpoint")) {
         gdbKind = Breakpoint::AccessBreakpoint;
     } else {
         qCWarning(DEBUGGERCOMMON) << "Unknown breakpoint type " << type;
         return;
     }
 
     // During debugger startup, we want to avoid creating duplicate breakpoints when the same breakpoint
     // appears both in our model and in a init file e.g. .gdbinit
     BreakpointModel* model = breakpointModel();
     const int numRows = model->rowCount();
     for (int row = 0; row < numRows; ++row) {
         BreakpointDataPtr breakpoint = m_breakpoints.at(row);
         const bool breakpointSent = breakpoint->debuggerId >= 0 || breakpoint->sent != 0;
         if (breakpointSent && !m_deleteDuplicateBreakpoints)
             continue;
 
         Breakpoint* modelBreakpoint = model->breakpoint(row);
         if (modelBreakpoint->kind() != gdbKind)
             continue;
 
         if (gdbKind == Breakpoint::CodeBreakpoint) {
             bool sameLocation = false;
 
             if (miBkpt.hasField(QStringLiteral("fullname")) && miBkpt.hasField(QStringLiteral("line"))) {
                 const QString location = Utils::unquoteExpression(miBkpt[QStringLiteral("fullname")].literal());
                 const int line = miBkpt[QStringLiteral("line")].toInt() - 1;
                 if (location == modelBreakpoint->url().url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash) &&
                     line == modelBreakpoint->line())
                 {
                     sameLocation = true;
                 }
             }
 
             if (!sameLocation && miBkpt.hasField(QStringLiteral("original-location"))) {
                 const QString location = miBkpt[QStringLiteral("original-location")].literal();
                 if (location == modelBreakpoint->location()) {
                     sameLocation = true;
                 } else {
                     QRegExp rx("^(.+):(\\d+)$");
                     if (rx.indexIn(location) != -1 &&
                         Utils::unquoteExpression(rx.cap(1)) == modelBreakpoint->url().url(QUrl::PreferLocalFile | QUrl::StripTrailingSlash) &&
                         rx.cap(2).toInt() - 1 == modelBreakpoint->line()) {
                         sameLocation = true;
                     }
                 }
             }
 
             if (!sameLocation && miBkpt.hasField(QStringLiteral("what")) && miBkpt[QStringLiteral("what")].literal() == QLatin1String("exception throw")) {
                 if (modelBreakpoint->expression() == QLatin1String("catch throw") ||
                     modelBreakpoint->expression() == QLatin1String("exception throw")) {
                     sameLocation = true;
                 }
             }
 
             if (!sameLocation)
                 continue;
         } else {
             if (Utils::unquoteExpression(miBkpt[QStringLiteral("original-location")].literal()) != modelBreakpoint->expression()) {
                 continue;
             }
         }
 
         QString condition;
         if (miBkpt.hasField(QStringLiteral("cond"))) {
             condition = miBkpt[QStringLiteral("cond")].literal();
         }
         if (condition != modelBreakpoint->condition())
             continue;
 
         // Breakpoint is equivalent
         if (!breakpointSent) {
             breakpoint->debuggerId = miBkpt[QStringLiteral("number")].toInt();
 
             // Reasonable people can probably have different opinions about what the "correct" behavior
             // should be for the "enabled" and "ignore hits" column.
             // Here, we let the status in KDevelop's UI take precedence, which we suspect to be
             // marginally more useful. Dirty data will be sent during the initial sending of the
             // breakpoint list.
             const bool gdbEnabled = miBkpt[QStringLiteral("enabled")].literal() == QLatin1String("y");
             if (gdbEnabled != modelBreakpoint->enabled())
                 breakpoint->dirty |= BreakpointModel::EnableColumnFlag;
 
             int gdbIgnoreHits = 0;
             if (miBkpt.hasField(QStringLiteral("ignore")))
                 gdbIgnoreHits = miBkpt[QStringLiteral("ignore")].toInt();
             if (gdbIgnoreHits != modelBreakpoint->ignoreHits())
                 breakpoint->dirty |= BreakpointModel::IgnoreHitsColumnFlag;
 
             updateFromDebugger(row, miBkpt, BreakpointModel::EnableColumnFlag | BreakpointModel::IgnoreHitsColumnFlag);
             return;
         }
 
         // Breakpoint from the model has already been sent, but we want to delete duplicates
         // It is not entirely clear _which_ breakpoint ought to be deleted, and reasonable people
         // may have different opinions.
         // We suspect that it is marginally more useful to delete the existing model breakpoint;
         // after all, this only happens when a user command creates a breakpoint, and perhaps the
         // user intends to modify the breakpoint they created manually. In any case,
         // this situation should only happen rarely (in particular, when a user sets a breakpoint
         // inside the remote run script).
         model->removeRows(row, 1);
         break; // fall through to pick up the manually created breakpoint in the model
     }
 
     // No equivalent breakpoint found, or we have one but want to be consistent with GDB's
     // behavior of allowing multiple equivalent breakpoint.
     IgnoreChanges ignoreChanges(*this);
     const int row = m_breakpoints.size();
     Q_ASSERT(row == model->rowCount());
 
     switch (gdbKind) {
     case Breakpoint::WriteBreakpoint: model->addWatchpoint(); break;
     case Breakpoint::ReadBreakpoint: model->addReadWatchpoint(); break;
     case Breakpoint::AccessBreakpoint: model->addAccessWatchpoint(); break;
     case Breakpoint::CodeBreakpoint: model->addCodeBreakpoint(); break;
     default: Q_ASSERT(false); return;
     }
 
     // Since we are in ignore-changes mode, we have to add the BreakpointData manually.
     auto breakpoint = BreakpointDataPtr::create();
     m_breakpoints << breakpoint;
     breakpoint->debuggerId = miBkpt[QStringLiteral("number")].toInt();
 
     updateFromDebugger(row, miBkpt);
 }
 
 // This method is required for the legacy interface which will be removed
 void MIBreakpointController::sendMaybe(KDevelop::Breakpoint*)
 {
     Q_ASSERT(false);
 }
 
 void MIBreakpointController::updateFromDebugger(int row, const Value& miBkpt, BreakpointModel::ColumnFlags lockedColumns)
 {
     IgnoreChanges ignoreChanges(*this);
     BreakpointDataPtr breakpoint = m_breakpoints[row];
     Breakpoint* modelBreakpoint = breakpointModel()->breakpoint(row);
 
     // Commands that are currently in flight will overwrite the modification we have received,
     // so do not update the corresponding data
     lockedColumns |= breakpoint->sent | breakpoint->dirty;
 
     // TODO:
     // Gdb has a notion of "original-location", which is the "expression" or "location" used
     // to set the breakpoint, and notions of the actual location of the breakpoint (function name,
     // address, source file and line). The breakpoint model currently does not map well to this
     // (though it arguably should), and does not support multi-location breakpoints at all.
     // We try to do the best we can until the breakpoint model gets cleaned up.
     if (miBkpt.hasField(QStringLiteral("fullname")) && miBkpt.hasField(QStringLiteral("line"))) {
         modelBreakpoint->setLocation(
             QUrl::fromLocalFile(Utils::unquoteExpression(miBkpt[QStringLiteral("fullname")].literal())),
             miBkpt[QStringLiteral("line")].toInt() - 1);
     } else if (miBkpt.hasField(QStringLiteral("original-location"))) {
         QRegExp rx("^(.+):(\\d+)$");
         QString location = miBkpt[QStringLiteral("original-location")].literal();
         if (rx.indexIn(location) != -1) {
             modelBreakpoint->setLocation(QUrl::fromLocalFile(Utils::unquoteExpression(rx.cap(1))),
                                          rx.cap(2).toInt()-1);
         } else {
             modelBreakpoint->setData(Breakpoint::LocationColumn, Utils::unquoteExpression(location));
         }
     } else if (miBkpt.hasField(QStringLiteral("what"))) {
         modelBreakpoint->setExpression(miBkpt[QStringLiteral("what")].literal());
     } else {
-        qWarning() << "Breakpoint doesn't contain required location/expression data";
+        qCWarning(DEBUGGERCOMMON) << "Breakpoint doesn't contain required location/expression data";
     }
 
     if (!(lockedColumns & BreakpointModel::EnableColumnFlag)) {
         bool enabled = true;
         if (miBkpt.hasField(QStringLiteral("enabled"))) {
             if (miBkpt[QStringLiteral("enabled")].literal() == QLatin1String("n"))
                 enabled = false;
         }
         modelBreakpoint->setData(Breakpoint::EnableColumn, enabled ? Qt::Checked : Qt::Unchecked);
         breakpoint->dirty &= ~BreakpointModel::EnableColumnFlag;
     }
 
     if (!(lockedColumns & BreakpointModel::ConditionColumnFlag)) {
         QString condition;
         if (miBkpt.hasField(QStringLiteral("cond"))) {
             condition = miBkpt[QStringLiteral("cond")].literal();
         }
         modelBreakpoint->setCondition(condition);
         breakpoint->dirty &= ~BreakpointModel::ConditionColumnFlag;
     }
 
     if (!(lockedColumns & BreakpointModel::IgnoreHitsColumnFlag)) {
         int ignoreHits = 0;
         if (miBkpt.hasField(QStringLiteral("ignore"))) {
             ignoreHits = miBkpt[QStringLiteral("ignore")].toInt();
         }
         modelBreakpoint->setIgnoreHits(ignoreHits);
         breakpoint->dirty &= ~BreakpointModel::IgnoreHitsColumnFlag;
     }
 
     breakpoint->pending = false;
     if (miBkpt.hasField(QStringLiteral("addr")) && miBkpt[QStringLiteral("addr")].literal() == QLatin1String("<PENDING>")) {
         breakpoint->pending = true;
     }
 
     int hitCount = 0;
     if (miBkpt.hasField(QStringLiteral("times"))) {
         hitCount = miBkpt[QStringLiteral("times")].toInt();
     }
     updateHitCount(row, hitCount);
 
     recalculateState(row);
 }
 
 void MIBreakpointController::programStopped(const AsyncRecord& r)
 {
     if (!r.hasField(QStringLiteral("reason")))
         return;
 
     const QString reason = r[QStringLiteral("reason")].literal();
 
     int debuggerId = -1;
     if (reason == QLatin1String("breakpoint-hit")) {
         debuggerId = r[QStringLiteral("bkptno")].toInt();
     } else if (reason == QLatin1String("watchpoint-trigger")) {
         debuggerId = r[QStringLiteral("wpt")][QStringLiteral("number")].toInt();
     } else if (reason == QLatin1String("read-watchpoint-trigger")) {
         debuggerId = r[QStringLiteral("hw-rwpt")][QStringLiteral("number")].toInt();
     } else if (reason == QLatin1String("access-watchpoint-trigger")) {
         debuggerId = r[QStringLiteral("hw-awpt")][QStringLiteral("number")].toInt();
     }
 
     if (debuggerId < 0)
         return;
 
     int row = rowFromDebuggerId(debuggerId);
     if (row < 0)
         return;
 
     QString msg;
     if (r.hasField(QStringLiteral("value"))) {
         if (r[QStringLiteral("value")].hasField(QStringLiteral("old"))) {
             msg += i18n("<br>Old value: %1", r["value"]["old"].literal());
         }
         if (r[QStringLiteral("value")].hasField(QStringLiteral("new"))) {
             msg += i18n("<br>New value: %1", r["value"]["new"].literal());
         }
     }
 
     notifyHit(row, msg);
 }
diff --git a/debuggers/common/registers/registersmanager.cpp b/debuggers/common/registers/registersmanager.cpp
index d455c6d578..d2e7be1e47 100644
--- a/debuggers/common/registers/registersmanager.cpp
+++ b/debuggers/common/registers/registersmanager.cpp
@@ -1,171 +1,171 @@
 /*
  * Creates RegistersView and RegisterController based on current architecture.
  * Copyright 2013  Vlas Puhov <vlas.puhov@mail.ru>
  *
  * 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 "registersmanager.h"
 
 #include "registercontroller_arm.h"
 #include "registercontroller_x86.h"
 #include "registersview.h"
 
 #include "dbgglobal.h"
 #include "debuglog.h"
 #include "midebugsession.h"
 #include "mi/micommand.h"
 #include "modelsmanager.h"
 
 using namespace KDevMI::MI;
 using namespace KDevMI;
 
 void ArchitectureParser::parseArchitecture()
 {
     Architecture arch = other;
 
     foreach (const QString & reg, m_registerNames) {
         if (reg == QLatin1String("rax")) {
             arch = x86_64;
             break;
         } else if (reg == QLatin1String("r0")) {
             arch = arm;
             break;
         } else if (reg == QLatin1String("eax")) {
             arch = x86;
             //we don't break because x86_64 contains eax too.
         }
     }
 
     emit architectureParsed(arch);
 }
 
 void ArchitectureParser::registerNamesHandler(const ResultRecord& r)
 {
     const Value& names = r[QStringLiteral("register-names")];
 
     m_registerNames.clear();
     for (int i = 0; i < names.size(); ++i) {
         const Value& entry = names[i];
         if (!entry.literal().isEmpty()) {
             m_registerNames << entry.literal();
         }
     }
 
     parseArchitecture();
 }
 
 void ArchitectureParser::determineArchitecture(MIDebugSession* debugSession)
 {
     if (!debugSession || debugSession->debuggerStateIsOn(s_dbgNotStarted | s_shuttingDown)) {
         return;
     }
 
     debugSession->addCommand(DataListRegisterNames, QLatin1String(""), this, &ArchitectureParser::registerNamesHandler);
 }
 
 RegistersManager::RegistersManager(QWidget* parent)
 : QObject(parent), m_registersView(new RegistersView(parent)), m_registerController(nullptr), m_architectureParser(new ArchitectureParser(this)), m_debugSession(nullptr), m_modelsManager(new ModelsManager(this)), m_currentArchitecture(undefined), m_needToCheckArch(false)
 {
     connect(m_architectureParser, &ArchitectureParser::architectureParsed, this, &RegistersManager::architectureParsedSlot);
 
     m_registersView->setModel(m_modelsManager);
     setController(nullptr);
 }
 
 void RegistersManager::architectureParsedSlot(Architecture arch)
 {
     qCDebug(DEBUGGERCOMMON) << " Current controller: " << m_registerController << "Current arch " << m_currentArchitecture;
 
     if (m_registerController || m_currentArchitecture != undefined) {
         return;
     }
 
     switch (arch) {
     case x86:
         m_registerController.reset(new RegisterController_x86(m_debugSession)) ;
         qCDebug(DEBUGGERCOMMON) << "Found x86 architecture";
         break;
     case x86_64:
         m_registerController.reset(new RegisterController_x86_64(m_debugSession));
         qCDebug(DEBUGGERCOMMON) << "Found x86_64 architecture";
         break;
     case arm:
         m_registerController.reset(new RegisterController_Arm(m_debugSession));
         qCDebug(DEBUGGERCOMMON) << "Found Arm architecture";
         break;
     default:
         m_registerController.reset();
-        qWarning() << "Unsupported architecture. Registers won't be available.";
+        qCWarning(DEBUGGERCOMMON) << "Unsupported architecture. Registers won't be available.";
         break;
     }
 
     m_currentArchitecture = arch;
 
     setController(m_registerController.data());
 
     if (m_registerController) {
         updateRegisters();
     }
 }
 
 void RegistersManager::setSession(MIDebugSession* debugSession)
 {
     qCDebug(DEBUGGERCOMMON) << "Change session " << debugSession;
     m_debugSession = debugSession;
     if (m_registerController) {
         m_registerController->setSession(debugSession);
     }
     if (!m_debugSession) {
         qCDebug(DEBUGGERCOMMON) << "Will reparse arch";
         m_needToCheckArch = true;
         setController(nullptr);
     }
 }
 
 void RegistersManager::updateRegisters()
 {
     if (!m_debugSession || m_debugSession->debuggerStateIsOn(s_dbgNotStarted | s_shuttingDown)) {
         return;
     }
 
     qCDebug(DEBUGGERCOMMON) << "Updating registers";
     if (m_needToCheckArch) {
         m_needToCheckArch = false;
         m_currentArchitecture = undefined;
         setController(nullptr);
     }
     if (m_currentArchitecture == undefined) {
         m_architectureParser->determineArchitecture(m_debugSession);
     }
 
     if (m_registerController) {
         m_registersView->updateRegisters();
     } else {
         qCDebug(DEBUGGERCOMMON) << "No registerController, yet?";
     }
 }
 
 ArchitectureParser::ArchitectureParser(QObject* parent)
 : QObject(parent) {}
 
 void RegistersManager::setController(IRegisterController* c)
 {
     m_registerController.reset(c);
     m_modelsManager->setController(c);
 
     m_registersView->enable(c ? true : false);
 }
diff --git a/debuggers/gdb/gdbconfigpage.cpp b/debuggers/gdb/gdbconfigpage.cpp
index 184bfebc5a..65de6cddc0 100644
--- a/debuggers/gdb/gdbconfigpage.cpp
+++ b/debuggers/gdb/gdbconfigpage.cpp
@@ -1,185 +1,184 @@
 /*
 * GDB Debugger Support
 *
 * Copyright 2006 Vladimir Prus <ghost@cs.msu.su>
 * Copyright 2007 Hamish Rodda <rodda@kde.org>
 * Copyright 2009 Andreas Pakulat <apaku@gmx.de>
 *
 * 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 "gdbconfigpage.h"
 
-#include <QDebug>
-
 #include <kconfiggroup.h>
 #include <KLocalizedString>
 #include <kmessagebox.h>
 
 #include <interfaces/idebugcontroller.h>
 #include <interfaces/ilaunchconfiguration.h>
 #include <interfaces/iproject.h>
 #include <util/executecompositejob.h>
 #include <execute/iexecuteplugin.h>
 
 #include "dbgglobal.h"
 #include "debuggerplugin.h"
+#include "debuglog.h"
 #include "midebugjobs.h"
 
 #include "ui_gdbconfigpage.h"
 #include <interfaces/iruncontroller.h>
 #include <interfaces/icore.h>
 
 using namespace KDevelop;
 namespace Config = KDevMI::GDB::Config;
 
 GdbConfigPage::GdbConfigPage( QWidget* parent )
     : LaunchConfigurationPage(parent), ui( new Ui::GdbConfigPage )
 {
     ui->setupUi( this );
     ui->kcfg_gdbPath->setMode(KFile::File|KFile::ExistingOnly|KFile::LocalOnly);
     connect(ui->kcfg_asmDemangle, &QCheckBox::toggled, this, &GdbConfigPage::changed);
     connect(ui->kcfg_configGdbScript, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     //connect(ui->kcfg_dbgTerminal, SIGNAL(toggled(bool)), this, SIGNAL(changed()));
     connect(ui->kcfg_debuggingShell, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_displayStaticMembers, &QCheckBox::toggled, this, &GdbConfigPage::changed);
     connect(ui->kcfg_gdbPath, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_runGdbScript, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_runShellScript, &KUrlRequester::textChanged, this, &GdbConfigPage::changed);
     connect(ui->kcfg_startWith, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &GdbConfigPage::changed);
 
     //Setup data info for combobox
     ui->kcfg_startWith->setItemData(0, "ApplicationOutput" );
     ui->kcfg_startWith->setItemData(1, "GdbConsole" );
     ui->kcfg_startWith->setItemData(2, "FrameStack" );
 }
 
 GdbConfigPage::~GdbConfigPage()
 {
     delete ui;
 }
 
 QIcon GdbConfigPage::icon() const
 {
     return QIcon();
 }
 
 void GdbConfigPage::loadFromConfiguration( const KConfigGroup& cfg, KDevelop::IProject*  )
 {
     bool block = blockSignals( true );
     ui->kcfg_gdbPath->setUrl( cfg.readEntry( Config::GdbPathEntry, QUrl() ) );
     ui->kcfg_debuggingShell->setUrl( cfg.readEntry( Config::DebuggerShellEntry, QUrl() ) );
     ui->kcfg_configGdbScript->setUrl( cfg.readEntry( Config::RemoteGdbConfigEntry, QUrl() ) );
     ui->kcfg_runShellScript->setUrl( cfg.readEntry( Config::RemoteGdbShellEntry, QUrl() ) );
     ui->kcfg_runGdbScript->setUrl( cfg.readEntry( Config::RemoteGdbRunEntry, QUrl() ) );
     ui->kcfg_displayStaticMembers->setChecked( cfg.readEntry( Config::StaticMembersEntry, false ) );
     ui->kcfg_asmDemangle->setChecked( cfg.readEntry( Config::DemangleNamesEntry, true) );
     ui->kcfg_startWith->setCurrentIndex( ui->kcfg_startWith->findData( cfg.readEntry( KDevMI::Config::StartWithEntry, "ApplicationOutput" ) ) );
     blockSignals( block );
 }
 
 void GdbConfigPage::saveToConfiguration( KConfigGroup cfg, KDevelop::IProject* ) const
 {
     cfg.writeEntry(Config::GdbPathEntry, ui->kcfg_gdbPath->url() );
     cfg.writeEntry(Config::DebuggerShellEntry, ui->kcfg_debuggingShell->url() );
     cfg.writeEntry(Config::RemoteGdbConfigEntry, ui->kcfg_configGdbScript->url() );
     cfg.writeEntry(Config::RemoteGdbShellEntry, ui->kcfg_runShellScript->url() );
     cfg.writeEntry(Config::RemoteGdbRunEntry, ui->kcfg_runGdbScript->url() );
     cfg.writeEntry(Config::StaticMembersEntry, ui->kcfg_displayStaticMembers->isChecked() );
     cfg.writeEntry(Config::DemangleNamesEntry, ui->kcfg_asmDemangle->isChecked() );
     cfg.writeEntry(KDevMI::Config::StartWithEntry, ui->kcfg_startWith->itemData( ui->kcfg_startWith->currentIndex() ).toString() );
 }
 
 QString GdbConfigPage::title() const
 {
     return i18n( "GDB Configuration" );
 }
 
 
 GdbLauncher::GdbLauncher( KDevMI::GDB::CppDebuggerPlugin* p, IExecutePlugin* execute )
     : m_plugin( p )
     , m_execute( execute )
 {
     factoryList << new GdbConfigPageFactory();
 }
 
 QList< KDevelop::LaunchConfigurationPageFactory* > GdbLauncher::configPages() const
 {
     return factoryList;
 }
 
 QString GdbLauncher::id()
 {
     return QStringLiteral("gdb");
 }
 
 QString GdbLauncher::name() const
 {
     return i18n("GDB");
 }
 
 KJob* GdbLauncher::start(const QString& launchMode, KDevelop::ILaunchConfiguration* cfg)
 {
     Q_ASSERT(cfg);
     if( !cfg )
     {
         return nullptr;
     }
     if( launchMode == QLatin1String("debug") )
     {
         Q_ASSERT(m_execute);
         Q_ASSERT(m_plugin);
 
         if (KDevelop::ICore::self()->debugController()->currentSession() != nullptr) {
             KMessageBox::ButtonCode answer = KMessageBox::warningYesNo(
                 nullptr,
                 i18n("A program is already being debugged. Do you want to abort the "
                      "currently running debug session and continue with the launch?"));
             if (answer == KMessageBox::No)
                 return nullptr;
         }
 
         QList<KJob*> l;
         KJob* depjob = m_execute->dependencyJob(cfg);
         if( depjob )
         {
             l << depjob;
         }
         l << new KDevMI::MIDebugJob( m_plugin, cfg, m_execute );
         return new KDevelop::ExecuteCompositeJob( KDevelop::ICore::self()->runController(), l );
     }
-    qWarning() << "Unknown launch mode" << launchMode << "for config:" << cfg->name();
+    qCWarning(DEBUGGERGDB) << "Unknown launch mode" << launchMode << "for config:" << cfg->name();
     return nullptr;
 }
 
 QStringList GdbLauncher::supportedModes() const
 {
     return QStringList() << QStringLiteral("debug");
 }
 
 QString GdbLauncher::description() const
 {
     return i18n("Executes a native application in GDB");
 }
 
 KDevelop::LaunchConfigurationPage* GdbConfigPageFactory::createWidget( QWidget* parent )
 {
     return new GdbConfigPage( parent );
 }
 
 
 
diff --git a/documentation/qthelp/qthelpdocumentation.cpp b/documentation/qthelp/qthelpdocumentation.cpp
index 073b1a2b1b..2cc50fc8e9 100644
--- a/documentation/qthelp/qthelpdocumentation.cpp
+++ b/documentation/qthelp/qthelpdocumentation.cpp
@@ -1,352 +1,352 @@
 /*  This file is part of KDevelop
     Copyright 2009 Aleix Pol <aleixpol@kde.org>
     Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
     Copyright 2010 Benjamin Port <port.benjamin@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 "qthelpdocumentation.h"
 
 #include <QLabel>
 #include <QUrl>
 #include <QTreeView>
 #include <QHelpContentModel>
 #include <QHeaderView>
 #include <QMenu>
 #include <QTemporaryFile>
 #include <QRegularExpression>
 
 #include <KLocalizedString>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentationcontroller.h>
 #include <documentation/standarddocumentationview.h>
 #include "qthelpnetwork.h"
 #include "qthelpproviderabstract.h"
 
 using namespace KDevelop;
 
 namespace {
 #if QT_VERSION >= 0x050500
 int indexOf(const QString& str, const QRegularExpression& re, int from, QRegularExpressionMatch* rmatch)
 {
     return str.indexOf(re, from, rmatch);
 }
 
 int lastIndexOf(const QString& str, const QRegularExpression& re, int from, QRegularExpressionMatch* rmatch)
 {
     return str.lastIndexOf(re, from, rmatch);
 }
 #else
 int indexOf(const QString& str, const QRegularExpression& re, int from, QRegularExpressionMatch* rmatch)
 {
     if (!re.isValid()) {
-        qWarning("QString::indexOf: invalid QRegularExpression object");
+        qCWarning(QTHELP) << "QString::indexOf: invalid QRegularExpression object";
         return -1;
     }
 
     QRegularExpressionMatch match = re.match(str, from);
     if (match.hasMatch()) {
         const int ret = match.capturedStart();
         if (rmatch)
             *rmatch = qMove(match);
         return ret;
     }
 
     return -1;
 }
 
 int lastIndexOf(const QString &str, const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch)
 {
     if (!re.isValid()) {
-        qWarning("QString::lastIndexOf: invalid QRegularExpression object");
+        qCWarning(QTHELP) << "QString::lastIndexOf: invalid QRegularExpression object";
         return -1;
     }
 
     int endpos = (from < 0) ? (str.size() + from + 1) : (from + 1);
     QRegularExpressionMatchIterator iterator = re.globalMatch(str);
     int lastIndex = -1;
     while (iterator.hasNext()) {
         QRegularExpressionMatch match = iterator.next();
         int start = match.capturedStart();
         if (start < endpos) {
             lastIndex = start;
             if (rmatch)
                 *rmatch = qMove(match);
         } else {
             break;
         }
     }
 
     return lastIndex;
 }
 #endif
 
 }
 
 QtHelpProviderAbstract* QtHelpDocumentation::s_provider=nullptr;
 
 QtHelpDocumentation::QtHelpDocumentation(const QString& name, const QMap<QString, QUrl>& info)
     : m_provider(s_provider), m_name(name), m_info(info), m_current(info.constBegin()), lastView(nullptr)
 {}
 
 QtHelpDocumentation::QtHelpDocumentation(const QString& name, const QMap<QString, QUrl>& info, const QString& key)
     : m_provider(s_provider), m_name(name), m_info(info), m_current(m_info.find(key)), lastView(nullptr)
 { Q_ASSERT(m_current!=m_info.constEnd()); }
 
 QtHelpDocumentation::~QtHelpDocumentation()
 {
 }
 
 QString QtHelpDocumentation::description() const
 {
     QUrl url(m_current.value());
     QByteArray data = m_provider->engine()->fileData(url);
 
     //Extract a short description from the html data
     const QString dataString = QString::fromLatin1(data); ///@todo encoding
 
     const QString fragment = url.fragment();
     const QString p = QStringLiteral("((\\\")|(\\\'))");
     const QString optionalSpace = QStringLiteral("( )*");
     const QString exp = QString("< a name = " + p + fragment + p + " > < / a >").replace(' ', optionalSpace);
 
     const QRegularExpression findFragment(exp);
     QRegularExpressionMatch findFragmentMatch;
     int pos = indexOf(dataString, findFragment, 0, &findFragmentMatch);
 
     if(fragment.isEmpty()) {
         pos = 0;
     } else {
 
         //Check if there is a title opening-tag right before the fragment, and if yes add it, so we have a nicely formatted caption
         const QString titleRegExp = QStringLiteral("< h\\d class = \".*\" >").replace(' ', optionalSpace);
         const QRegularExpression findTitle(titleRegExp);
         const QRegularExpressionMatch match = findTitle.match(dataString, pos);
         const int titleStart = match.capturedStart();
         const int titleEnd = titleStart + match.capturedEnd();
         if(titleStart != -1) {
             const QStringRef between = dataString.midRef(titleEnd, pos-titleEnd).trimmed();
             if(between.isEmpty())
                 pos = titleStart;
         }
     }
 
     if(pos != -1) {
         const QString exp = QString("< a name = " + p + "((\\S)*)" + p + " > < / a >").replace(' ', optionalSpace);
         const QRegularExpression nextFragmentExpression(exp);
         int endPos = dataString.indexOf(nextFragmentExpression, pos+(fragment.size() ? findFragmentMatch.capturedLength() : 0));
         if(endPos == -1) {
             endPos = dataString.size();
         }
 
         {
             //Find the end of the last paragraph or newline, so we don't add prefixes of the following fragment
             const QString newLineRegExp = QStringLiteral ("< br / > | < / p >").replace(' ', optionalSpace);
             const QRegularExpression lastNewLine(newLineRegExp);
             QRegularExpressionMatch match;
             const int newEnd = lastIndexOf(dataString, lastNewLine, endPos, &match);
             if(match.isValid() && newEnd > pos)
                 endPos = newEnd + match.capturedLength();
         }
 
         {
             //Find the title, and start from there
             const QString titleRegExp = QStringLiteral("< h\\d class = \"title\" >").replace(' ', optionalSpace);
             const QRegularExpression findTitle(titleRegExp);
             const QRegularExpressionMatch match = findTitle.match(dataString);
             if (match.isValid())
                 pos = qBound(pos, match.capturedStart(), endPos);
         }
 
 
         QString thisFragment = dataString.mid(pos, endPos - pos);
 
         {
             //Completely remove the first large header found, since we don't need a header
             const QString headerRegExp = QStringLiteral("< h\\d.*>.*?< / h\\d >").replace(' ', optionalSpace);
             const QRegularExpression findHeader(headerRegExp);
             const QRegularExpressionMatch match = findHeader.match(thisFragment);
             if(match.isValid()) {
                 thisFragment.remove(match.capturedStart(), match.capturedLength());
             }
         }
 
         {
             //Replace all gigantic header-font sizes with <big>
             {
                 const QString sizeRegExp = QStringLiteral("< h\\d ").replace(' ', optionalSpace);
                 const QRegularExpression findSize(sizeRegExp);
                 thisFragment.replace(findSize, QStringLiteral("<big "));
             }
             {
                 const QString sizeCloseRegExp = QStringLiteral("< / h\\d >").replace(' ', optionalSpace);
                 const QRegularExpression closeSize(sizeCloseRegExp);
                 thisFragment.replace(closeSize, QStringLiteral("</big><br />"));
             }
         }
 
         {
             //Replace paragraphs by newlines
             const QString begin = QStringLiteral("< p >").replace(' ', optionalSpace);
             const QRegularExpression findBegin(begin);
             thisFragment.replace(findBegin, {});
 
             const QString end = QStringLiteral("< /p >").replace(' ', optionalSpace);
             const QRegularExpression findEnd(end);
             thisFragment.replace(findEnd, QStringLiteral("<br />"));
         }
 
         {
             //Remove links, because they won't work
             const QString link = QString("< a href = " + p + ".*?" + p).replace(' ', optionalSpace);
             const QRegularExpression exp(link, QRegularExpression::CaseInsensitiveOption);
             thisFragment.replace(exp, QStringLiteral("<a "));
         }
 
         return thisFragment;
     }
 
     return QStringList(m_info.keys()).join(QStringLiteral(", "));
 }
 
 void QtHelpDocumentation::setUserStyleSheet(StandardDocumentationView* view, const QUrl& url)
 {
 
     QTemporaryFile* file = new QTemporaryFile(view);
     file->open();
 
     QTextStream ts(file);
     ts << "html { background: white !important; }\n";
     if (url.scheme() == QLatin1String("qthelp") && url.host().startsWith(QLatin1String("com.trolltech.qt."))) {
        ts << ".content .toc + .title + p { clear:left; }\n"
           << "#qtdocheader .qtref { position: absolute !important; top: 5px !important; right: 0 !important; }\n";
     }
     file->close();
     view->setOverrideCss(QUrl::fromLocalFile(file->fileName()));
 
     delete m_lastStyleSheet.data();
     m_lastStyleSheet = file;
 }
 
 QWidget* QtHelpDocumentation::documentationWidget(DocumentationFindWidget* findWidget, QWidget* parent)
 {
     if(m_info.isEmpty()) { //QtHelp sometimes has empty info maps. e.g. availableaudioeffects i 4.5.2
         return new QLabel(i18n("Could not find any documentation for '%1'", m_name), parent);
     } else {
         StandardDocumentationView* view = new StandardDocumentationView(findWidget, parent);
         view->initZoom(m_provider->name());
         if (!m_sharedQNAM) {
             m_sharedQNAM.reset(new HelpNetworkAccessManager(m_provider->engine()));
         }
         view->setNetworkAccessManager(m_sharedQNAM.data());
         view->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(view, &StandardDocumentationView::customContextMenuRequested, this, &QtHelpDocumentation::viewContextMenuRequested);
 
         setUserStyleSheet(view, m_current.value());
         view->load(m_current.value());
         lastView = view;
         return view;
     }
 }
 
 void QtHelpDocumentation::viewContextMenuRequested(const QPoint& pos)
 {
     StandardDocumentationView* view = qobject_cast<StandardDocumentationView*>(sender());
     if (!view)
         return;
 
     QMenu menu;
     QAction* copyAction = view->copyAction();
     copyAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-copy")));
     menu.addAction(copyAction);
 
     if (m_info.count() > 1) {
         menu.addSeparator();
 
         QActionGroup* actionGroup = new QActionGroup(&menu);
         foreach(const QString& name, m_info.keys()) {
             QtHelpAlternativeLink* act=new QtHelpAlternativeLink(name, this, actionGroup);
             act->setCheckable(true);
             act->setChecked(name==m_current.key());
             menu.addAction(act);
         }
     }
 
     menu.exec(view->mapToGlobal(pos));
 }
 
 
 void QtHelpDocumentation::jumpedTo(const QUrl& newUrl)
 {
     Q_ASSERT(lastView);
     m_provider->jumpedTo(newUrl);
     setUserStyleSheet(lastView, newUrl);
     lastView->load(newUrl);
 }
 
 IDocumentationProvider* QtHelpDocumentation::provider() const
 {
     return m_provider;
 }
 
 QtHelpAlternativeLink::QtHelpAlternativeLink(const QString& name, const QtHelpDocumentation* doc, QObject* parent)
     : QAction(name, parent), mDoc(doc), mName(name)
 {
     connect(this, &QtHelpAlternativeLink::triggered, this, &QtHelpAlternativeLink::showUrl);
 }
 
 void QtHelpAlternativeLink::showUrl()
 {
     IDocumentation::Ptr newDoc(new QtHelpDocumentation(mName, mDoc->info(), mName));
     ICore::self()->documentationController()->showDocumentation(newDoc);
 }
 
 HomeDocumentation::HomeDocumentation() : m_provider(QtHelpDocumentation::s_provider)
 {
 }
 
 QWidget* HomeDocumentation::documentationWidget(DocumentationFindWidget*, QWidget* parent)
 {
     QTreeView* w=new QTreeView(parent);
     w->header()->setVisible(false);
     w->setModel(m_provider->engine()->contentModel());
 
     connect(w, &QTreeView::clicked, this, &HomeDocumentation::clicked);
     return w;
 }
 
 void HomeDocumentation::clicked(const QModelIndex& idx)
 {
     QHelpContentModel* model = m_provider->engine()->contentModel();
     QHelpContentItem* it=model->contentItemAt(idx);
     QMap<QString, QUrl> info;
     info.insert(it->title(), it->url());
 
     IDocumentation::Ptr newDoc(new QtHelpDocumentation(it->title(), info));
     ICore::self()->documentationController()->showDocumentation(newDoc);
 }
 
 QString HomeDocumentation::name() const
 {
     return i18n("QtHelp Home Page");
 }
 
 IDocumentationProvider* HomeDocumentation::provider() const
 {
     return m_provider;
 }
diff --git a/documentation/qthelp/qthelpproviderabstract.cpp b/documentation/qthelp/qthelpproviderabstract.cpp
index 165d7f30b8..029e0a8ae9 100644
--- a/documentation/qthelp/qthelpproviderabstract.cpp
+++ b/documentation/qthelp/qthelpproviderabstract.cpp
@@ -1,110 +1,110 @@
 /*  This file is part of KDevelop
     Copyright 2009 Aleix Pol <aleixpol@kde.org>
     Copyright 2009 David Nolden <david.nolden.kdevelop@art-master.de>
     Copyright 2010 Benjamin Port <port.benjamin@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 "qthelpprovider.h"
 
 #include <QHelpIndexModel>
 #include <QHelpContentModel>
 
 #include <QStandardPaths>
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/declaration.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/parsingenvironment.h>
 
 #include "qthelpdocumentation.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 QtHelpProviderAbstract::QtHelpProviderAbstract(QObject *parent, const QString &collectionFileName, const QVariantList &args)
     : QObject(parent)
     , m_engine(QStandardPaths::writableLocation(QStandardPaths::DataLocation)+'/'+collectionFileName)
 {
     Q_UNUSED(args);
     if( !m_engine.setupData() ) {
-        qWarning() << "Couldn't setup QtHelp Collection file";
+        qCWarning(QTHELP) << "Couldn't setup QtHelp Collection file";
     }
 }
 
 
 QtHelpProviderAbstract::~QtHelpProviderAbstract()
 {
 }
 
 IDocumentation::Ptr QtHelpProviderAbstract::documentationForDeclaration(Declaration* dec) const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     if (dec) {
         static const IndexedString qmlJs("QML/JS");
         QString id;
 
         {
             DUChainReadLocker lock;
             id = dec->qualifiedIdentifier().toString(RemoveTemplateInformation);
             if (dec->topContext()->parsingEnvironmentFile()->language() == qmlJs && !id.isEmpty())
                 id = QLatin1String("QML.") + id;
         }
 
         if (!id.isEmpty()) {
             QMap<QString, QUrl> links = m_engine.linksForIdentifier(id);
 
             if(!links.isEmpty())
                 return IDocumentation::Ptr(new QtHelpDocumentation(id, links));
         }
     }
 
     return {};
 }
 
 QAbstractListModel* QtHelpProviderAbstract::indexModel() const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     return m_engine.indexModel();
 }
 
 IDocumentation::Ptr QtHelpProviderAbstract::documentationForIndex(const QModelIndex& idx) const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     QString name=idx.data(Qt::DisplayRole).toString();
     return IDocumentation::Ptr(new QtHelpDocumentation(name, m_engine.indexModel()->linksForKeyword(name)));
 }
 
 void QtHelpProviderAbstract::jumpedTo(const QUrl& newUrl) const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     QMap<QString, QUrl> info;
     info.insert(newUrl.toString(), newUrl);
     IDocumentation::Ptr doc(new QtHelpDocumentation(newUrl.toString(), info));
     emit addHistory(doc);
 }
 
 IDocumentation::Ptr QtHelpProviderAbstract::homePage() const
 {
     QtHelpDocumentation::s_provider = const_cast<QtHelpProviderAbstract*>(this);
     return IDocumentation::Ptr(new HomeDocumentation);
 }
 
 bool QtHelpProviderAbstract::isValid() const
 {
     return !m_engine.registeredDocumentations().isEmpty();
 }
diff --git a/formatters/customscript/customscript_plugin.cpp b/formatters/customscript/customscript_plugin.cpp
index c303ce8582..64b531b69c 100644
--- a/formatters/customscript/customscript_plugin.cpp
+++ b/formatters/customscript/customscript_plugin.cpp
@@ -1,551 +1,551 @@
 /* This file is part of KDevelop
    Copyright (C) 2008 Cédric Pasteur <cedric.pasteur@free.fr>
    Copyright (C) 2011 David Nolden <david.nolden.kdevelop@art-master.de>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU 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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
  */
 
 #include "customscript_plugin.h"
 
 #include <KPluginFactory>
 #include <QTextStream>
 #include <QTemporaryFile>
 #include <QMimeDatabase>
 #include <KProcess>
 #include <interfaces/icore.h>
 #include <interfaces/isourceformattercontroller.h>
 #include <interfaces/isourceformatter.h>
 #include <memory>
 #include <QDir>
 #include <QLoggingCategory>
 Q_DECLARE_LOGGING_CATEGORY(CUSTOMSCRIPT)
 Q_LOGGING_CATEGORY(CUSTOMSCRIPT, "kdevelop.formatters.customscript")
 
 #include <util/formattinghelpers.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <KMessageBox>
 #include <interfaces/iuicontroller.h>
 #include <KParts/MainWindow>
 #include <KLocalizedString>
 #include <interfaces/ilanguagecontroller.h>
 #include <language/interfaces/ilanguagesupport.h>
 #include <util/path.h>
 
 using namespace KDevelop;
 
 static QPointer<CustomScriptPlugin> indentPluginSingleton;
 
 K_PLUGIN_FACTORY_WITH_JSON(CustomScriptFactory, "kdevcustomscript.json", registerPlugin<CustomScriptPlugin>(); )
 
 // Replaces ${KEY} in command with variables[KEY]
 static QString replaceVariables(QString command, QMap<QString, QString> variables)
 {
     while (command.contains(QLatin1String("${"))) {
         int pos = command.indexOf(QLatin1String("${"));
         int end = command.indexOf(QLatin1String("}"), pos + 2);
         if (end == -1) {
             break;
         }
         QString key = command.mid(pos + 2, end - pos - 2);
 
         if (variables.contains(key)) {
             command.replace(pos, 1 + end - pos, variables[key]);
         } else {
             qCDebug(CUSTOMSCRIPT) << "found no variable while replacing in shell-command" << command << "key" << key << "available:" << variables;
             command.replace(pos, 1 + end - pos, QLatin1String(""));
         }
     }
     return command;
 }
 
 CustomScriptPlugin::CustomScriptPlugin(QObject* parent, const QVariantList&)
     : IPlugin(QStringLiteral("kdevcustomscript"), parent)
 {
     m_currentStyle = predefinedStyles().at(0);
     indentPluginSingleton = this;
 }
 
 CustomScriptPlugin::~CustomScriptPlugin()
 {
 }
 
 QString CustomScriptPlugin::name()
 {
     // This needs to match the X-KDE-PluginInfo-Name entry from the .desktop file!
     return QStringLiteral("kdevcustomscript");
 }
 
 QString CustomScriptPlugin::caption()
 {
     return QStringLiteral("Custom Script Formatter");
 }
 
 QString CustomScriptPlugin::description()
 {
     return i18n("<b>Indent and Format Source Code.</b><br />"
                 "This plugin allows using powerful external formatting tools "
                 "that can be invoked through the command-line.<br />"
                 "For example, the <b>uncrustify</b>, <b>astyle</b> or <b>indent</b> "
                 "formatters can be used.<br />"
                 "The advantage of command-line formatters is that formatting configurations "
                 "can be easily shared by all team members, independent of their preferred IDE.");
 }
 
 QString CustomScriptPlugin::formatSourceWithStyle(SourceFormatterStyle style, const QString& text, const QUrl& url, const QMimeType& /*mime*/, const QString& leftContext, const QString& rightContext)
 {
     KProcess proc;
     QTextStream ios(&proc);
 
     std::unique_ptr<QTemporaryFile> tmpFile;
 
     if (style.content().isEmpty()) {
         style = predefinedStyle(style.name());
         if (style.content().isEmpty()) {
-            qWarning() << "Empty contents for style" << style.name() << "for indent plugin";
+            qCWarning(CUSTOMSCRIPT) << "Empty contents for style" << style.name() << "for indent plugin";
             return text;
         }
     }
 
     QString useText = text;
     useText = leftContext + useText + rightContext;
 
     QMap<QString, QString> projectVariables;
     foreach (IProject* project, ICore::self()->projectController()->projects()) {
         projectVariables[project->name()] = project->path().toUrl().toLocalFile();
     }
 
     QString command = style.content();
 
     // Replace ${Project} with the project path
     command = replaceVariables(command, projectVariables);
     command.replace(QLatin1String("$FILE"), url.toLocalFile());
 
     if (command.contains(QLatin1String("$TMPFILE"))) {
         tmpFile.reset(new QTemporaryFile(QDir::tempPath() + "/code"));
         tmpFile->setAutoRemove(false);
         if (tmpFile->open()) {
             qCDebug(CUSTOMSCRIPT) << "using temporary file" << tmpFile->fileName();
             command.replace(QLatin1String("$TMPFILE"), tmpFile->fileName());
             QByteArray useTextArray = useText.toLocal8Bit();
             if (tmpFile->write(useTextArray) != useTextArray.size()) {
-                qWarning() << "failed to write text to temporary file";
+                qCWarning(CUSTOMSCRIPT) << "failed to write text to temporary file";
                 return text;
             }
         } else {
-            qWarning() << "Failed to create a temporary file";
+            qCWarning(CUSTOMSCRIPT) << "Failed to create a temporary file";
             return text;
         }
         tmpFile->close();
     }
 
     qCDebug(CUSTOMSCRIPT) << "using shell command for indentation: " << command;
     proc.setShellCommand(command);
     proc.setOutputChannelMode(KProcess::OnlyStdoutChannel);
 
     proc.start();
     if (!proc.waitForStarted()) {
         qCDebug(CUSTOMSCRIPT) << "Unable to start indent" << endl;
         return text;
     }
 
     if (!tmpFile.get()) {
         proc.write(useText.toLocal8Bit());
     }
 
     proc.closeWriteChannel();
     if (!proc.waitForFinished()) {
         qCDebug(CUSTOMSCRIPT) << "Process doesn't finish" << endl;
         return text;
     }
 
     QString output;
 
     if (tmpFile.get()) {
         QFile f(tmpFile->fileName());
         if (f.open(QIODevice::ReadOnly)) {
             output = QString::fromLocal8Bit(f.readAll());
         } else {
-            qWarning() << "Failed opening the temporary file for reading";
+            qCWarning(CUSTOMSCRIPT) << "Failed opening the temporary file for reading";
             return text;
         }
     } else {
         output = ios.readAll();
     }
     if (output.isEmpty()) {
-        qWarning() << "indent returned empty text for style" << style.name() << style.content();
+        qCWarning(CUSTOMSCRIPT) << "indent returned empty text for style" << style.name() << style.content();
         return text;
     }
 
     int tabWidth = 4;
     if ((!leftContext.isEmpty() || !rightContext.isEmpty()) && (text.contains('	') || output.contains('	'))) {
         // If we have to do contex-matching with tabs, determine the correct tab-width so that the context
         // can be matched correctly
         Indentation indent = indentation(url);
         if (indent.indentationTabWidth > 0) {
             tabWidth = indent.indentationTabWidth;
         }
     }
 
     return KDevelop::extractFormattedTextFromContext(output, text, leftContext, rightContext, tabWidth);
 }
 
 QString CustomScriptPlugin::formatSource(const QString& text, const QUrl& url, const QMimeType& mime, const QString& leftContext, const QString& rightContext)
 {
     return formatSourceWithStyle(KDevelop::ICore::self()->sourceFormatterController()->styleForMimeType(mime), text, url, mime, leftContext, rightContext);
 }
 
 static QList<SourceFormatterStyle> stylesFromLanguagePlugins()
 {
     QList<KDevelop::SourceFormatterStyle> styles;
     foreach (auto lang, ICore::self()->languageController()->loadedLanguages()) {
         const SourceFormatterItemList& languageStyles = lang->sourceFormatterItems();
         for (const SourceFormatterStyleItem& item: languageStyles) {
             if (item.engine == QLatin1String("customscript")) {
                 styles << item.style;
             }
         }
     }
 
     return styles;
 };
 
 KDevelop::SourceFormatterStyle CustomScriptPlugin::predefinedStyle(const QString& name)
 {
     for (auto langStyle: stylesFromLanguagePlugins()) {
         qCDebug(CUSTOMSCRIPT) << "looking at style from language with custom sample" << langStyle.description() << langStyle.overrideSample();
         if (langStyle.name() == name) {
             return langStyle;
         }
     }
 
     SourceFormatterStyle result(name);
     if (name == QLatin1String("GNU_indent_GNU")) {
         result.setCaption(i18n("Gnu Indent: GNU"));
         result.setContent(QStringLiteral("indent"));
     } else if (name == QLatin1String("GNU_indent_KR")) {
         result.setCaption(i18n("Gnu Indent: Kernighan & Ritchie"));
         result.setContent(QStringLiteral("indent -kr"));
     } else if (name == QLatin1String("GNU_indent_orig")) {
         result.setCaption(i18n("Gnu Indent: Original Berkeley indent style"));
         result.setContent(QStringLiteral("indent -orig"));
     } else if (name == QLatin1String("kdev_format_source")) {
         result.setCaption(QStringLiteral("KDevelop: kdev_format_source"));
         result.setContent(QStringLiteral("kdev_format_source $FILE $TMPFILE"));
         result.setUsePreview(false);
         result.setDescription(i18n("Description:<br />"
                                    "<b>kdev_format_source</b> is a script bundled with KDevelop "
                                    "which allows using fine-grained formatting rules by placing "
                                    "meta-files called <b>format_sources</b> into the file-system.<br /><br />"
                                    "Each line of the <b>format_sources</b> files defines a list of wildcards "
                                    "followed by a colon and the used formatting-command.<br /><br />"
                                    "The formatting-command should use <b>$TMPFILE</b> to reference the "
                                    "temporary file to reformat.<br /><br />"
                                    "Example:<br />"
                                    "<b>*.cpp *.h : myformatter $TMPFILE</b><br />"
                                    "This will reformat all files ending with <b>.cpp</b> or <b>.h</b> using "
                                    "the custom formatting script <b>myformatter</b>.<br /><br />"
                                    "Example: <br />"
                                    "<b>subdir/* : uncrustify -l CPP -f $TMPFILE -c uncrustify.config -o $TMPFILE</b> <br />"
                                    "This will reformat all files in subdirectory <b>subdir</b> using the <b>uncrustify</b> "
                                    "tool with the config-file <b>uncrustify.config</b>."));
     }
     result.setMimeTypes({
         {"text/x-c++src", "C++"}, {"text/x-chdr", "C"},
         {"text/x-c++hdr", "C++"}, {"text/x-csrc", "C"},
         {"text/x-java", "Java"}, {"text/x-csharp", "C#"}
     });
     return result;
 }
 
 QList<KDevelop::SourceFormatterStyle> CustomScriptPlugin::predefinedStyles()
 {
     QList<KDevelop::SourceFormatterStyle> styles = stylesFromLanguagePlugins();
     styles << predefinedStyle(QStringLiteral("kdev_format_source"));
     styles << predefinedStyle(QStringLiteral("GNU_indent_GNU"));
     styles << predefinedStyle(QStringLiteral("GNU_indent_KR"));
     styles << predefinedStyle(QStringLiteral("GNU_indent_orig"));
     return styles;
 }
 
 KDevelop::SettingsWidget* CustomScriptPlugin::editStyleWidget(const QMimeType& mime)
 {
     Q_UNUSED(mime);
     return new CustomScriptPreferences();
 }
 
 static QString formattingSample()
 {
     return
         "// Formatting\n"
         "void func(){\n"
         "\tif(isFoo(a,b))\n"
         "\tbar(a,b);\n"
         "if(isFoo)\n"
         "\ta=bar((b-c)*a,*d--);\n"
         "if(  isFoo( a,b ) )\n"
         "\tbar(a, b);\n"
         "if (isFoo) {isFoo=false;cat << isFoo <<endl;}\n"
         "if(isFoo)DoBar();if (isFoo){\n"
         "\tbar();\n"
         "}\n"
         "\telse if(isBar()){\n"
         "\tannotherBar();\n"
         "}\n"
         "int var = 1;\n"
         "int *ptr = &var;\n"
         "int &ref = i;\n"
         "\n"
         "QList<int>::const_iterator it = list.begin();\n"
         "}\n"
         "namespace A {\n"
         "namespace B {\n"
         "void foo() {\n"
         "  if (true) {\n"
         "    func();\n"
         "  } else {\n"
         "    // bla\n"
         "  }\n"
         "}\n"
         "}\n"
         "}\n";
 }
 
 static QString indentingSample()
 {
     return
         "// Indentation\n"
         "#define foobar(A)\\\n"
         "{Foo();Bar();}\n"
         "#define anotherFoo(B)\\\n"
         "return Bar()\n"
         "\n"
         "namespace Bar\n"
         "{\n"
         "class Foo\n"
         "{public:\n"
         "Foo();\n"
         "virtual ~Foo();\n"
         "};\n"
         "switch (foo)\n"
         "{\n"
         "case 1:\n"
         "a+=1;\n"
         "break;\n"
         "case 2:\n"
         "{\n"
         "a += 2;\n"
         " break;\n"
         "}\n"
         "}\n"
         "if (isFoo)\n"
         "{\n"
         "bar();\n"
         "}\n"
         "else\n"
         "{\n"
         "anotherBar();\n"
         "}\n"
         "int foo()\n"
         "\twhile(isFoo)\n"
         "\t\t{\n"
         "\t\t\t...\n"
         "\t\t\tgoto error;\n"
         "\t\t....\n"
         "\t\terror:\n"
         "\t\t\t...\n"
         "\t\t}\n"
         "\t}\n"
         "fooArray[]={ red,\n"
         "\tgreen,\n"
         "\tdarkblue};\n"
         "fooFunction(barArg1,\n"
         "\tbarArg2,\n"
         "\tbarArg3);\n";
 }
 
 QString CustomScriptPlugin::previewText(const SourceFormatterStyle& style, const QMimeType& /*mime*/)
 {
     if (!style.overrideSample().isEmpty()) {
         return style.overrideSample();
     }
     return formattingSample() + "\n\n" + indentingSample();
 }
 
 QStringList CustomScriptPlugin::computeIndentationFromSample(const QUrl& url)
 {
     QStringList ret;
 
     auto languages = ICore::self()->languageController()->languagesForUrl(url);
     if (languages.isEmpty()) {
         return ret;
     }
 
     QString sample = languages[0]->indentationSample();
     QString formattedSample = formatSource(sample, url, QMimeDatabase().mimeTypeForUrl(url), QString(), QString());
 
     QStringList lines = formattedSample.split(QStringLiteral("\n"));
     foreach (QString line, lines) {
         if (!line.isEmpty() && line[0].isSpace()) {
             QString indent;
             foreach (QChar c, line) {
                 if (c.isSpace()) {
                     indent.push_back(c);
                 } else {
                     break;
                 }
             }
 
             if (!indent.isEmpty() && !ret.contains(indent)) {
                 ret.push_back(indent);
             }
         }
     }
 
     return ret;
 }
 
 CustomScriptPlugin::Indentation CustomScriptPlugin::indentation(const QUrl& url)
 {
     Indentation ret;
     QStringList indent = computeIndentationFromSample(url);
     if (indent.isEmpty()) {
         qCDebug(CUSTOMSCRIPT) << "failed extracting a valid indentation from sample for url" << url;
         return ret; // No valid indentation could be extracted
     }
 
     if (indent[0].contains(' ')) {
         ret.indentWidth = indent[0].count(' ');
     }
 
     if (!indent.join(QLatin1String("")).contains('	')) {
         ret.indentationTabWidth = -1;         // Tabs are not used for indentation
     }
     if (indent[0] == QLatin1String("	")) {
         // The script indents with tabs-only
         // The problem is that we don't know how
         // wide a tab is supposed to be.
         //
         // We need indentation-width=tab-width
         // to make the editor do tab-only formatting,
         // so choose a random with of 4.
         ret.indentWidth = 4;
         ret.indentationTabWidth = 4;
     } else if (ret.indentWidth)   {
         // Tabs are used for indentation, alongside with spaces
         // Try finding out how many spaces one tab stands for.
         // Do it by assuming a uniform indentation-step with each level.
 
         for (int pos = 0; pos < indent.size(); ++pos) {
             if (indent[pos] == QLatin1String("	")&& pos >= 1) {
                 // This line consists of only a tab.
                 int prevWidth = indent[pos - 1].length();
                 int prevPrevWidth = (pos >= 2) ? indent[pos - 2].length() : 0;
                 int step = prevWidth - prevPrevWidth;
                 qCDebug(CUSTOMSCRIPT) << "found in line " << pos << prevWidth << prevPrevWidth << step;
                 if (step > 0 && step <= prevWidth) {
                     qCDebug(CUSTOMSCRIPT) << "Done";
                     ret.indentationTabWidth = prevWidth + step;
                     break;
                 }
             }
         }
     }
 
     qCDebug(CUSTOMSCRIPT) << "indent-sample" << "\"" + indent.join(QStringLiteral("\n")) + "\"" << "extracted tab-width" << ret.indentationTabWidth << "extracted indentation width" << ret.indentWidth;
 
     return ret;
 }
 
 void CustomScriptPreferences::updateTimeout()
 {
     const QString& text = indentPluginSingleton.data()->previewText(m_style, QMimeType());
     QString formatted = indentPluginSingleton.data()->formatSourceWithStyle(m_style, text, QUrl(), QMimeType());
     emit previewTextChanged(formatted);
 }
 
 CustomScriptPreferences::CustomScriptPreferences()
 {
     m_updateTimer = new QTimer(this);
     m_updateTimer->setSingleShot(true);
     connect(m_updateTimer, &QTimer::timeout, this, &CustomScriptPreferences::updateTimeout);
     m_vLayout = new QVBoxLayout(this);
     m_captionLabel = new QLabel;
     m_vLayout->addWidget(m_captionLabel);
     m_vLayout->addSpacing(10);
     m_hLayout = new QHBoxLayout;
     m_vLayout->addLayout(m_hLayout);
     m_commandLabel = new QLabel;
     m_hLayout->addWidget(m_commandLabel);
     m_commandEdit = new QLineEdit;
     m_hLayout->addWidget(m_commandEdit);
     m_commandLabel->setText(i18n("Command:"));
     m_vLayout->addSpacing(10);
     m_bottomLabel = new QLabel;
     m_vLayout->addWidget(m_bottomLabel);
     m_bottomLabel->setTextFormat(Qt::RichText);
     m_bottomLabel->setText(
         i18n("<i>You can enter an arbitrary shell command.</i><br />"
              "The unformatted source-code is reached to the command <br />"
              "through the standard input, and the <br />"
              "formatted result is read from the standard output.<br />"
              "<br />"
              "If you add <b>$TMPFILE</b> into the command, then <br />"
              "a temporary file is used for transferring the code."));
     connect(m_commandEdit, &QLineEdit::textEdited, this, &CustomScriptPreferences::textEdited);
 
     m_vLayout->addSpacing(10);
 
     m_moreVariablesButton = new QPushButton(i18n("More Variables"));
     connect(m_moreVariablesButton, &QPushButton::clicked, this, &CustomScriptPreferences::moreVariablesClicked);
     m_vLayout->addWidget(m_moreVariablesButton);
 }
 
 void CustomScriptPreferences::load(const KDevelop::SourceFormatterStyle& style)
 {
     m_style = style;
     m_commandEdit->setText(style.content());
     m_captionLabel->setText(i18n("Style: %1", style.caption()));
 
     updateTimeout();
 }
 
 QString CustomScriptPreferences::save()
 {
     return m_commandEdit->text();
 }
 
 void CustomScriptPreferences::moreVariablesClicked(bool)
 {
     KMessageBox::information(ICore::self()->uiController()->activeMainWindow(),
                              i18n("<b>$TMPFILE</b> will be replaced with the path to a temporary file. <br />"
                                   "The code will be written into the file, the temporary <br />"
                                   "file will be substituted into that position, and the result <br />"
                                   "will be read out of that file. <br />"
                                   "<br />"
                                   "<b>$FILE</b> will be replaced with the path of the original file. <br />"
                                   "The contents of the file must not be modified, changes are allowed <br />"
                                   "only in $TMPFILE.<br />"
                                   "<br />"
                                   "<b>${PROJECT_NAME}</b> will be replaced by the path of <br />"
                                   "the currently open project with the matching name."
 
                                   ), i18n("Variable Replacements"));
 }
 
 #include "customscript_plugin.moc"
 
 // kate: indent-mode cstyle; space-indent off; tab-width 4;
diff --git a/languages/clang/duchain/parsesession.cpp b/languages/clang/duchain/parsesession.cpp
index 5d07de74cd..1fccf8965d 100644
--- a/languages/clang/duchain/parsesession.cpp
+++ b/languages/clang/duchain/parsesession.cpp
@@ -1,490 +1,490 @@
 /*
     This file is part of KDevelop
 
     Copyright 2013 Olivier de Gaalon <olivier.jg@gmail.com>
     Copyright 2013 Milian Wolff <mail@milianw.de>
     Copyright 2013 Kevin Funk <kfunk@kde.org>
 
     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 "parsesession.h"
 #include <QStandardPaths>
 #include "clangproblem.h"
 #include "clangdiagnosticevaluator.h"
 #include "todoextractor.h"
 #include "clanghelpers.h"
 #include "clangindex.h"
 #include "clangparsingenvironment.h"
 #include "util/clangdebug.h"
 #include "util/clangtypes.h"
 #include "util/clangutils.h"
 
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchain.h>
 
 #include <KShell>
 
 #include <QDir>
 #include <QFileInfo>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace {
 
 QVector<QByteArray> extraArgs()
 {
     const auto extraArgsString = QString::fromLatin1(qgetenv("KDEV_CLANG_EXTRA_ARGUMENTS"));
     const auto extraArgs = KShell::splitArgs(extraArgsString);
 
     // transform to list of QByteArrays
     QVector<QByteArray> result;
     result.reserve(extraArgs.size());
     foreach (const QString& arg, extraArgs) {
         result << arg.toLatin1();
     }
     clangDebug() << "Passing extra arguments to clang:" << result;
 
     return result;
 }
 
 QVector<QByteArray> argsForSession(const QString& path, ParseSessionData::Options options, const ParserSettings& parserSettings)
 {
     QMimeDatabase db;
     if(db.mimeTypeForFile(path).name() == QStringLiteral("text/x-objcsrc")) {
         return {QByteArrayLiteral("-xobjective-c++")};
     }
 
     // TODO: No proper mime type detection possible yet
     // cf. https://bugs.freedesktop.org/show_bug.cgi?id=26913
     if (path.endsWith(QLatin1String(".cl"), Qt::CaseInsensitive)) {
         return {QByteArrayLiteral("-xcl")};
     }
 
     // TODO: No proper mime type detection possible yet
     // cf. https://bugs.freedesktop.org/show_bug.cgi?id=23700
     if (path.endsWith(QLatin1String(".cu"), Qt::CaseInsensitive)) {
         return {QByteArrayLiteral("-xcuda")};
     }
 
     if (parserSettings.parserOptions.isEmpty()) {
         // The parserOptions can be empty for some unit tests that use ParseSession directly
         auto defaultArguments = ClangSettingsManager::self()->parserSettings(path).toClangAPI();
         defaultArguments.append(QByteArrayLiteral("-nostdinc"));
         defaultArguments.append(QByteArrayLiteral("-nostdinc++"));
         defaultArguments.append(QByteArrayLiteral("-xc++"));
         return defaultArguments;
     }
 
     auto result = parserSettings.toClangAPI();
     result.append(QByteArrayLiteral("-nostdinc"));
     if (parserSettings.isCpp()) {
         result.append(QByteArrayLiteral("-nostdinc++"));
     }
 
     if (options & ParseSessionData::PrecompiledHeader) {
         result.append(parserSettings.isCpp() ? QByteArrayLiteral("-xc++-header") : QByteArrayLiteral("-xc-header"));
         return result;
     }
 
     result.append(parserSettings.isCpp() ? QByteArrayLiteral("-xc++") : QByteArrayLiteral("-xc"));
     return result;
 }
 
 void addIncludes(QVector<const char*>* args, QVector<QByteArray>* otherArgs,
                  const Path::List& includes, const char* cliSwitch)
 {
     foreach (const Path& url, includes) {
         if (url.isEmpty()) {
             continue;
         }
         
         QFileInfo info(url.toLocalFile());
         QByteArray path = url.toLocalFile().toUtf8();
 
         if (info.isFile()) {
             path.prepend("-include");
         } else {
             path.prepend(cliSwitch);
         }
         otherArgs->append(path);
         args->append(path.constData());
     }
 }
 
 void addFrameworkDirectories(QVector<const char*>* args, QVector<QByteArray>* otherArgs,
                  const Path::List& frameworkDirectories, const char* cliSwitch)
 {
     foreach (const Path& url, frameworkDirectories) {
         if (url.isEmpty()) {
             continue;
         }
 
         QFileInfo info(url.toLocalFile());
         if (!info.isDir()) {
-            qWarning() << "supposed framework directory is not a directory:" << url.pathOrUrl();
+            qCWarning(KDEV_CLANG) << "supposed framework directory is not a directory:" << url.pathOrUrl();
             continue;
         }
         QByteArray path = url.toLocalFile().toUtf8();
 
         otherArgs->append(cliSwitch);
         otherArgs->append(path);
         args->append(cliSwitch);
         args->append(path.constData());
     }
 }
 
 QVector<CXUnsavedFile> toClangApi(const QVector<UnsavedFile>& unsavedFiles)
 {
     QVector<CXUnsavedFile> unsaved;
     unsaved.reserve(unsavedFiles.size());
     std::transform(unsavedFiles.begin(), unsavedFiles.end(),
                 std::back_inserter(unsaved),
                 [] (const UnsavedFile& file) { return file.toClangApi(); });
     return unsaved;
 }
 
 bool needGccCompatibility(const ClangParsingEnvironment& environment)
 {
     const auto& defines = environment.defines();
     // TODO: potentially do the same for the intel compiler?
     return defines.contains(QStringLiteral("__GNUC__"))
         && !environment.defines().contains(QStringLiteral("__clang__"));
 }
 
 bool hasQtIncludes(const Path::List& includePaths)
 {
     return std::find_if(includePaths.begin(), includePaths.end(), [] (const Path& path) {
         return path.lastPathSegment() == QLatin1String("QtCore");
     }) != includePaths.end();
 }
 
 }
 
 ParseSessionData::ParseSessionData(const QVector<UnsavedFile>& unsavedFiles, ClangIndex* index,
                                    const ClangParsingEnvironment& environment, Options options)
     : m_file(nullptr)
     , m_unit(nullptr)
 {
     unsigned int flags = CXTranslationUnit_CXXChainedPCH
         | CXTranslationUnit_DetailedPreprocessingRecord
 #if CINDEX_VERSION_MINOR >= 34
         | CXTranslationUnit_KeepGoing
 #endif
     ;
     if (options.testFlag(SkipFunctionBodies)) {
         flags |= CXTranslationUnit_SkipFunctionBodies;
     }
     if (options.testFlag(PrecompiledHeader)) {
         flags |= CXTranslationUnit_ForSerialization;
     } else {
         flags |= CXTranslationUnit_CacheCompletionResults
               |  CXTranslationUnit_PrecompiledPreamble;
         if (environment.quality() == ClangParsingEnvironment::Unknown) {
             flags |= CXTranslationUnit_Incomplete;
         }
     }
 
     const auto tuUrl = environment.translationUnitUrl();
     Q_ASSERT(!tuUrl.isEmpty());
 
     const auto arguments = argsForSession(tuUrl.str(), options, environment.parserSettings());
     QVector<const char*> clangArguments;
 
     const auto& includes = environment.includes();
     const auto& pchInclude = environment.pchInclude();
 
     // uses QByteArray as smart-pointer for const char* ownership
     QVector<QByteArray> smartArgs;
     smartArgs.reserve(includes.system.size() + includes.project.size()
                       + pchInclude.isValid() + arguments.size() + 1);
     clangArguments.reserve(smartArgs.size());
 
     std::transform(arguments.constBegin(), arguments.constEnd(),
                    std::back_inserter(clangArguments),
                    [] (const QByteArray &argument) { return argument.constData(); });
 
     // NOTE: the PCH include must come before all other includes!
     if (pchInclude.isValid()) {
         clangArguments << "-include";
         QByteArray pchFile = pchInclude.toLocalFile().toUtf8();
         smartArgs << pchFile;
         clangArguments << pchFile.constData();
     }
 
     if (needGccCompatibility(environment)) {
         const auto compatFile = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kdevclangsupport/gcc_compat.h")).toUtf8();
         if (!compatFile.isEmpty()) {
             smartArgs << compatFile;
             clangArguments << "-include" << compatFile.constData();
         }
     }
 
     if (hasQtIncludes(includes.system)) {
         const auto wrappedQtHeaders = QStandardPaths::locate(QStandardPaths::GenericDataLocation,
                                                              QStringLiteral("kdevclangsupport/wrappedQtHeaders"),
                                                              QStandardPaths::LocateDirectory).toUtf8();
         if (!wrappedQtHeaders.isEmpty()) {
             smartArgs << wrappedQtHeaders;
             clangArguments << "-isystem" << wrappedQtHeaders.constData();
             const auto qtCore = wrappedQtHeaders + "/QtCore";
             smartArgs << qtCore;
             clangArguments << "-isystem" << qtCore.constData();
         }
     }
 
     addIncludes(&clangArguments, &smartArgs, includes.system, "-isystem");
     addIncludes(&clangArguments, &smartArgs, includes.project, "-I");
 
     const auto& frameworkDirectories = environment.frameworkDirectories();
     addFrameworkDirectories(&clangArguments, &smartArgs, frameworkDirectories.system, "-iframework");
     addFrameworkDirectories(&clangArguments, &smartArgs, frameworkDirectories.project, "-F");
 
     smartArgs << writeDefinesFile(environment.defines());
     clangArguments << "-imacros" << smartArgs.last().constData();
 
     // append extra args from environment variable
     static const auto extraArgs = ::extraArgs();
     foreach (const QByteArray& arg, extraArgs) {
         clangArguments << arg.constData();
     }
 
     QVector<CXUnsavedFile> unsaved;
     //For PrecompiledHeader, we don't want unsaved contents (and contents.isEmpty())
     if (!options.testFlag(PrecompiledHeader)) {
         unsaved = toClangApi(unsavedFiles);
     }
 
     // debugging: print hypothetical clang invocation including args (for easy c&p for local testing)
     if (qEnvironmentVariableIsSet("KDEV_CLANG_DISPLAY_ARGS")) {
         QTextStream out(stdout);
         out << "Invocation: clang";
         foreach (const auto& arg, clangArguments) {
             out << " " << arg;
         }
         out << " " << tuUrl.byteArray().constData() << "\n";
     }
 
     const CXErrorCode code = clang_parseTranslationUnit2(
         index->index(), tuUrl.byteArray().constData(),
         clangArguments.constData(), clangArguments.size(),
         unsaved.data(), unsaved.size(),
         flags,
         &m_unit
     );
     if (code != CXError_Success) {
-        qWarning() << "clang_parseTranslationUnit2 return with error code" << code;
+        qCWarning(KDEV_CLANG) << "clang_parseTranslationUnit2 return with error code" << code;
         if (!qEnvironmentVariableIsSet("KDEV_CLANG_DISPLAY_DIAGS")) {
-            qWarning() << "  (start KDevelop with `KDEV_CLANG_DISPLAY_DIAGS=1 kdevelop` to see more diagnostics)";
+            qCWarning(KDEV_CLANG) << "  (start KDevelop with `KDEV_CLANG_DISPLAY_DIAGS=1 kdevelop` to see more diagnostics)";
         }
     }
 
     if (m_unit) {
         setUnit(m_unit);
         m_environment = environment;
 
         if (options.testFlag(PrecompiledHeader)) {
             clang_saveTranslationUnit(m_unit, (tuUrl.byteArray() + ".pch").constData(), CXSaveTranslationUnit_None);
         }
     } else {
-        qWarning() << "Failed to parse translation unit:" << tuUrl;
+        qCWarning(KDEV_CLANG) << "Failed to parse translation unit:" << tuUrl;
     }
 }
 
 ParseSessionData::~ParseSessionData()
 {
     clang_disposeTranslationUnit(m_unit);
 }
 
 QByteArray ParseSessionData::writeDefinesFile(const QMap<QString, QString>& defines)
 {
     m_definesFile.open();
     Q_ASSERT(m_definesFile.isWritable());
 
     QTextStream definesStream(&m_definesFile);
     // don't show warnings about redefined macros
     definesStream << "#pragma clang system_header\n";
     for (auto it = defines.begin(); it != defines.end(); ++it) {
         definesStream << QStringLiteral("#define ") << it.key() << ' ' << it.value() << '\n';
     }
 
     return m_definesFile.fileName().toUtf8();
 }
 
 void ParseSessionData::setUnit(CXTranslationUnit unit)
 {
     m_unit = unit;
     if (m_unit) {
         const ClangString unitFile(clang_getTranslationUnitSpelling(unit));
         m_file = clang_getFile(m_unit, unitFile.c_str());
     } else {
         m_file = nullptr;
     }
 }
 
 ClangParsingEnvironment ParseSessionData::environment() const
 {
     return m_environment;
 }
 
 ParseSession::ParseSession(const ParseSessionData::Ptr& data)
     : d(data)
 {
     if (d) {
         ENSURE_CHAIN_NOT_LOCKED
         d->m_mutex.lock();
     }
 }
 
 ParseSession::~ParseSession()
 {
     if (d) {
         d->m_mutex.unlock();
     }
 }
 
 void ParseSession::setData(const ParseSessionData::Ptr& data)
 {
     if (data == d) {
         return;
     }
 
     if (d) {
         d->m_mutex.unlock();
     }
 
     d = data;
 
     if (d) {
         ENSURE_CHAIN_NOT_LOCKED
         d->m_mutex.lock();
     }
 }
 
 ParseSessionData::Ptr ParseSession::data() const
 {
     return d;
 }
 
 IndexedString ParseSession::languageString()
 {
     static const IndexedString lang("Clang");
     return lang;
 }
 
 QList<ProblemPointer> ParseSession::problemsForFile(CXFile file) const
 {
     if (!d) {
         return {};
     }
 
     QList<ProblemPointer> problems;
 
     // extra clang diagnostics
     const uint numDiagnostics = clang_getNumDiagnostics(d->m_unit);
     problems.reserve(numDiagnostics);
     for (uint i = 0; i < numDiagnostics; ++i) {
         auto diagnostic = clang_getDiagnostic(d->m_unit, i);
 
         CXSourceLocation location = clang_getDiagnosticLocation(diagnostic);
         CXFile diagnosticFile;
         clang_getFileLocation(location, &diagnosticFile, nullptr, nullptr, nullptr);
         // missing-include problems are so severe in clang that we always propagate
         // them to this document, to ensure that the user will see the error.
         if (diagnosticFile != file && ClangDiagnosticEvaluator::diagnosticType(diagnostic) != ClangDiagnosticEvaluator::IncludeFileNotFoundProblem) {
             continue;
         }
 
         ProblemPointer problem(ClangDiagnosticEvaluator::createProblem(diagnostic, d->m_unit));
         problems << problem;
 
         clang_disposeDiagnostic(diagnostic);
     }
 
     // other problem sources
 
     TodoExtractor extractor(unit(), file);
     problems << extractor.problems();
 
 #if CINDEX_VERSION_MINOR > 30
     // note that the below warning is triggered on every reparse when there is a precompiled preamble
     // see also TestDUChain::testReparseIncludeGuard
     const QString path = QDir(ClangString(clang_getFileName(file)).toString()).canonicalPath();
     const IndexedString indexedPath(path);
     if (ClangHelpers::isHeader(path) && !clang_isFileMultipleIncludeGuarded(unit(), file)
         && !clang_Location_isInSystemHeader(clang_getLocationForOffset(d->m_unit, file, 0)))
     {
         ProblemPointer problem(new Problem);
         problem->setSeverity(IProblem::Warning);
         problem->setDescription(i18n("Header is not guarded against multiple inclusions"));
         problem->setExplanation(i18n("The given header is not guarded against multiple inclusions, "
             "either with the conventional #ifndef/#define/#endif macro guards or with #pragma once."));
         problem->setFinalLocation({indexedPath, KTextEditor::Range()});
         problem->setSource(IProblem::Preprocessor);
         problems << problem;
         // TODO: Easy to add an assistant here that adds the guards -- any takers?
     }
 #endif
 
     return problems;
 }
 
 CXTranslationUnit ParseSession::unit() const
 {
     return d ? d->m_unit : nullptr;
 }
 
 CXFile ParseSession::file(const QByteArray& path) const
 {
     return clang_getFile(unit(), path.constData());
 }
 
 CXFile ParseSession::mainFile() const
 {
     return d ? d->m_file : nullptr;
 }
 
 bool ParseSession::reparse(const QVector<UnsavedFile>& unsavedFiles, const ClangParsingEnvironment& environment)
 {
     if (!d || environment != d->m_environment) {
         return false;
     }
 
     auto unsaved = toClangApi(unsavedFiles);
 
     const auto code = clang_reparseTranslationUnit(d->m_unit, unsaved.size(), unsaved.data(),
                                                    clang_defaultReparseOptions(d->m_unit));
     if (code != CXError_Success) {
-        qWarning() << "clang_reparseTranslationUnit return with error code" << code;
+        qCWarning(KDEV_CLANG) << "clang_reparseTranslationUnit return with error code" << code;
         // if error code != 0 => clang_reparseTranslationUnit invalidates the old translation unit => clean up
         clang_disposeTranslationUnit(d->m_unit);
         d->setUnit(nullptr);
         return false;
     }
 
     // update state
     d->setUnit(d->m_unit);
     return true;
 }
 
 ClangParsingEnvironment ParseSession::environment() const
 {
     return d->m_environment;
 }
diff --git a/projectbuilders/cmakebuilder/cmakebuilder.cpp b/projectbuilders/cmakebuilder/cmakebuilder.cpp
index db18c5b1f7..c7ff49ebde 100644
--- a/projectbuilders/cmakebuilder/cmakebuilder.cpp
+++ b/projectbuilders/cmakebuilder/cmakebuilder.cpp
@@ -1,268 +1,268 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006-2007 Andreas Pakulat <apaku@gmx.de>
  *
  * 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 "cmakebuilder.h"
 #include "debug.h"
 
 #include <config.h>
 #include <cmakebuilderconfig.h>
 
 #include <project/projectmodel.h>
 
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <project/builderjob.h>
 #include <makebuilder/imakebuilder.h>
 
 #include <kpluginfactory.h>
 #include <KLocalizedString>
 #include <kjob.h>
 #include <QUrl>
 
 Q_LOGGING_CATEGORY(CMAKEBUILDER, "kdevelop.projectbuilders.cmakebuilder")
 
 #include "cmakejob.h"
 #include "prunejob.h"
 #include "cmakebuilderpreferences.h"
 #include "cmakeutils.h"
 #include <cmakemodelitems.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(CMakeBuilderFactory, "kdevcmakebuilder.json", registerPlugin<CMakeBuilder>(); )
 
 class ErrorJob : public KJob
 {
 public:
     ErrorJob(QObject* parent, const QString& error)
         : KJob(parent)
         , m_error(error)
     {}
 
     void start() override {
         setError(!m_error.isEmpty());
         setErrorText(m_error);
         emitResult();
     }
 
 private:
     QString m_error;
 };
 
 CMakeBuilder::CMakeBuilder(QObject *parent, const QVariantList &)
     : KDevelop::IPlugin(QStringLiteral("kdevcmakebuilder"), parent)
 {
     addBuilder(QStringLiteral("Makefile"), QStringList(QStringLiteral("Unix Makefiles")) << QStringLiteral("NMake Makefiles"), core()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IMakeBuilder")));
     addBuilder(QStringLiteral("build.ninja"), QStringList(QStringLiteral("Ninja")), core()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IProjectBuilder"), QStringLiteral("KDevNinjaBuilder")));
 }
 
 CMakeBuilder::~CMakeBuilder()
 {
 }
 
 void CMakeBuilder::addBuilder(const QString& neededfile, const QStringList& generators, KDevelop::IPlugin* i)
 {
     if( i )
     {
         IProjectBuilder* b = i->extension<KDevelop::IProjectBuilder>();
         if( b )
         {
             m_builders[neededfile] = b;
             foreach(const QString& gen, generators) {
                 m_buildersForGenerator[gen] = b;
             }
             // can't use new signal/slot syntax here, IProjectBuilder is not a QObject
             connect(i, SIGNAL(built(KDevelop::ProjectBaseItem*)), this, SIGNAL(built(KDevelop::ProjectBaseItem*)));
             connect(i, SIGNAL(failed(KDevelop::ProjectBaseItem*)), this, SIGNAL(failed(KDevelop::ProjectBaseItem*)));
             connect(i, SIGNAL(cleaned(KDevelop::ProjectBaseItem*)), this, SIGNAL(cleaned(KDevelop::ProjectBaseItem*)));
             connect(i, SIGNAL(installed(KDevelop::ProjectBaseItem*)), this, SIGNAL(installed(KDevelop::ProjectBaseItem*)));
 
             qCDebug(CMAKEBUILDER) << "Added builder " << i->metaObject()->className() << "for" << neededfile;
         }
         else
-            qWarning() << "Couldn't add" << i->metaObject()->className();
+            qCWarning(CMAKEBUILDER) << "Couldn't add" << i->metaObject()->className();
     }
 }
 
 KJob* CMakeBuilder::build(KDevelop::ProjectBaseItem *dom)
 {
     KDevelop::IProject* p = dom->project();
     IProjectBuilder* builder = builderForProject(p);
     if( builder )
     {
         bool valid;
         KJob* configure = checkConfigureJob(dom->project(), valid);
 
         KJob* build = nullptr;
         if(dom->file())
         {
             IMakeBuilder* makeBuilder = dynamic_cast<IMakeBuilder*>(builder);
             if (!makeBuilder) {
                 return new ErrorJob(this, i18n("Could not find the make builder. Check your installation"));
             }
             KDevelop::ProjectFileItem* file = dom->file();
             int lastDot = file->text().lastIndexOf('.');
             QString target = file->text().mid(0, lastDot)+".o";
             build = makeBuilder->executeMakeTarget(dom->parent(), target);
             qCDebug(CMAKEBUILDER) << "create build job for target" << build << dom << target;
         }
         qCDebug(CMAKEBUILDER) << "Building with" << builder;
         if (!build)
         {
             build = builder->build(dom);
         }
         if( configure )
         {
             qCDebug(CMAKEBUILDER) << "creating composite job";
             KDevelop::BuilderJob* builderJob = new KDevelop::BuilderJob;
             builderJob->addCustomJob( KDevelop::BuilderJob::Configure, configure, dom );
             builderJob->addCustomJob( KDevelop::BuilderJob::Build, build, dom );
             builderJob->updateJobName();
             build = builderJob;
         }
         return build;
     }
     return new ErrorJob(this, i18n("Could not find a builder for %1", p->name()));
 }
 
 KJob* CMakeBuilder::clean(KDevelop::ProjectBaseItem *dom)
 {
     IProjectBuilder* builder = builderForProject(dom->project());
     if( builder )
     {
         bool valid;
         KJob* configure = checkConfigureJob(dom->project(), valid);
 
         KDevelop::ProjectBaseItem* item = dom;
         if(dom->file()) //It doesn't work to compile a file
             item=(KDevelop::ProjectBaseItem*) dom->parent();
 
         qCDebug(CMAKEBUILDER) << "Cleaning with" << builder;
         KJob* clean = builder->clean(item);
         if( configure ) {
             KDevelop::BuilderJob* builderJob = new KDevelop::BuilderJob;
             builderJob->addCustomJob( KDevelop::BuilderJob::Configure, configure, item );
             builderJob->addCustomJob( KDevelop::BuilderJob::Clean, clean, item );
             builderJob->updateJobName();
             clean = builderJob;
         }
         return clean;
     }
     return new ErrorJob(this, i18n("Could not find a builder for %1", dom->project()->name()));
 }
 
 KJob* CMakeBuilder::install(KDevelop::ProjectBaseItem *dom, const QUrl &installPrefix)
 {
     IProjectBuilder* builder = builderForProject(dom->project());
     if( builder )
     {
         bool valid;
         KJob* configure = checkConfigureJob(dom->project(), valid);
 
         KDevelop::ProjectBaseItem* item = dom;
         if(dom->file())
             item=(KDevelop::ProjectBaseItem*) dom->parent();
 
         qCDebug(CMAKEBUILDER) << "Installing with" << builder;
         KJob* install = builder->install(item, installPrefix);
         if( configure ) {
             KDevelop::BuilderJob* builderJob = new KDevelop::BuilderJob;
             builderJob->addCustomJob( KDevelop::BuilderJob::Configure, configure, item );
             builderJob->addCustomJob( KDevelop::BuilderJob::Install, install, item );
             builderJob->updateJobName();
             install = builderJob;
         }
         return install;
 
     }
     return new ErrorJob(this, i18n("Could not find a builder for %1", dom->project()->name()));
 }
 
 KJob* CMakeBuilder::checkConfigureJob(KDevelop::IProject* project, bool& valid)
 {
     valid = false;
     KJob* configure = nullptr;
     if( CMake::checkForNeedingConfigure(project) )
     {
         configure = this->configure(project);
     }
     else if( CMake::currentBuildDir(project).isEmpty() )
     {
         return new ErrorJob(this, i18n("No Build Directory configured, cannot install"));
     }
     valid = true;
     return configure;
 }
 
 KJob* CMakeBuilder::configure( KDevelop::IProject* project )
 {
     if( CMake::currentBuildDir( project ).isEmpty() )
     {
         return new ErrorJob(this, i18n("No Build Directory configured, cannot configure"));
     }
     CMakeJob* job = new CMakeJob(this);
     job->setProject(project);
     connect(job, &KJob::result, this, [this, project] {
         emit configured(project);
     });
     return job;
 }
 
 KJob* CMakeBuilder::prune( KDevelop::IProject* project )
 {
     return new PruneJob(project);
 }
 
 KDevelop::IProjectBuilder* CMakeBuilder::builderForProject(KDevelop::IProject* p) const
 {
     QString builddir = CMake::currentBuildDir( p ).toLocalFile();
     QMap<QString, IProjectBuilder*>::const_iterator it = m_builders.constBegin(), itEnd = m_builders.constEnd();
     for(; it!=itEnd; ++it) {
         if(QFile::exists(builddir+'/'+it.key()))
             return it.value();
     }
     //It means that it still has to be generated, so use the builder for
     //the generator we use
     return m_buildersForGenerator[CMake::defaultGenerator()];
 }
 
 QList< KDevelop::IProjectBuilder* > CMakeBuilder::additionalBuilderPlugins( KDevelop::IProject* project  ) const
 {
     IProjectBuilder* b = builderForProject( project );
     QList< KDevelop::IProjectBuilder* > ret;
     if(b)
         ret << b;
     return ret;
 }
 
 int CMakeBuilder::configPages() const
 {
     return 1;
 }
 
 KDevelop::ConfigPage* CMakeBuilder::configPage(int number, QWidget* parent)
 {
     if (number == 0) {
         return new CMakeBuilderPreferences(this, parent);
     }
     return nullptr;
 }
 
 
 #include "cmakebuilder.moc"
diff --git a/projectbuilders/cmakebuilder/cmakejob.cpp b/projectbuilders/cmakebuilder/cmakejob.cpp
index 277d65aa0e..1671d5e471 100644
--- a/projectbuilders/cmakebuilder/cmakejob.cpp
+++ b/projectbuilders/cmakebuilder/cmakejob.cpp
@@ -1,138 +1,138 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006-2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2008 Hamish Rodda <rodda@kde.org>
  *
  * 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 "cmakejob.h"
 
 #include <cmakebuilderconfig.h>
 #include <cmakebuilder.h>
 
 #include <QDir>
 
 #include <project/projectmodel.h>
 
 #include <interfaces/iproject.h>
 
 #include <kshell.h>
 #include <klocalizedstring.h>
 
 #include "cmakeutils.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 CMakeJob::CMakeJob(QObject* parent)
     : OutputExecuteJob(parent)
     , m_project(nullptr)
 {
     setCapabilities( Killable );
     setFilteringStrategy( OutputModel::CompilerFilter );
     setProperties( NeedWorkingDirectory | PortableMessages | DisplayStderr | IsBuilderHint );
     setToolTitle( i18n("CMake") );
     setStandardToolView( KDevelop::IOutputView::BuildView );
     setBehaviours(KDevelop::IOutputView::AllowUserClose | KDevelop::IOutputView::AutoScroll );
 }
 
 void CMakeJob::start()
 {
     qCDebug(CMAKEBUILDER) << "Configuring cmake" << workingDirectory();
 
     if( !m_project ) {
         setError(NoProjectError);
         setErrorText(QStringLiteral("Internal error: no project specified to configure."));
         emitResult();
         return;
     }
 
     QDir::temp().mkpath(workingDirectory().toLocalFile());
     CMake::updateConfig( m_project, CMake::currentBuildDirIndex(m_project) );
 
     OutputExecuteJob::start();
 }
 
 QUrl CMakeJob::workingDirectory() const
 {
     KDevelop::Path path = CMake::currentBuildDir( m_project );
     qCDebug(CMAKEBUILDER) << "builddir: " << path;
     Q_ASSERT(path.isValid()); //We cannot get the project folder as a build directory!
     return path.toUrl();
 }
 
 QStringList CMakeJob::commandLine() const
 {
     QStringList args;
     args << CMake::currentCMakeExecutable(m_project).toLocalFile();
     args << QStringLiteral("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON");
 
     QString installDir = CMake::currentInstallDir( m_project ).toLocalFile();
     if( !installDir.isEmpty() )
     {
         args << QStringLiteral("-DCMAKE_INSTALL_PREFIX=%1").arg(installDir);
     }
     QString buildType = CMake::currentBuildType( m_project );
     if( !buildType.isEmpty() )
     {
         args << QStringLiteral("-DCMAKE_BUILD_TYPE=%1").arg(buildType);
     }
     QVariantMap cacheArgs = property("extraCMakeCacheValues").toMap();
     for( auto it = cacheArgs.constBegin(), itEnd = cacheArgs.constEnd(); it!=itEnd; ++it) {
         args << QStringLiteral("-D%1=%2").arg(it.key()).arg(it.value().toString());
     }
 
     //if we are creating a new build directory, we'll want to specify the generator
     QDir builddir(CMake::currentBuildDir( m_project ).toLocalFile());
     if(!builddir.exists() || !builddir.exists(QStringLiteral("CMakeCache.txt"))) {
         CMakeBuilderSettings::self()->load();
         args << QStringLiteral("-G") << CMake::defaultGenerator();
     }
     QString cmakeargs = CMake::currentExtraArguments( m_project );
     if( !cmakeargs.isEmpty() ) {
         KShell::Errors err;
         QStringList tmp = KShell::splitArgs( cmakeargs, KShell::TildeExpand | KShell::AbortOnMeta, &err );
         if( err == KShell::NoError ) {
             args += tmp;
         } else {
-            qWarning() << "Ignoring cmake Extra arguments";
+            qCWarning(CMAKEBUILDER) << "Ignoring cmake Extra arguments";
             if( err == KShell::BadQuoting ) {
-                qWarning() << "CMake arguments badly quoted:" << cmakeargs;
+                qCWarning(CMAKEBUILDER) << "CMake arguments badly quoted:" << cmakeargs;
             } else {
-                qWarning() << "CMake arguments had meta character:" << cmakeargs;
+                qCWarning(CMAKEBUILDER) << "CMake arguments had meta character:" << cmakeargs;
             }
         }
     }
     args << CMake::projectRoot( m_project ).toLocalFile();
 
     return args;
 }
 
 QString CMakeJob::environmentProfile() const
 {
     return CMake::currentEnvironment( m_project );
 }
 
 void CMakeJob::setProject(KDevelop::IProject* project)
 {
     m_project = project;
 
     if (m_project)
         setJobName( i18n("CMake: %1", m_project->name()) );
 }
 
diff --git a/projectbuilders/qmakebuilder/qmakejob.cpp b/projectbuilders/qmakebuilder/qmakejob.cpp
index 066a12190a..89c014081c 100644
--- a/projectbuilders/qmakebuilder/qmakejob.cpp
+++ b/projectbuilders/qmakebuilder/qmakejob.cpp
@@ -1,123 +1,123 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006-2007 Andreas Pakulat <apaku@gmx.de>
  * Copyright 2008 Hamish Rodda <rodda@kde.org>
  *
  * 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 "qmakejob.h"
 
 #include "debug.h"
 #include "qmakeconfig.h"
 
 #include <interfaces/iproject.h>
 #include <outputview/ioutputview.h>
 #include <outputview/outputmodel.h>
 #include <project/projectmodel.h>
 #include <makebuilder/imakebuilder.h>
 #include <util/commandexecutor.h>
 #include <util/path.h>
 
 #include <QDir>
 #include <KLocalizedString>
 
 using namespace KDevelop;
 
 QMakeJob::QMakeJob(QObject* parent)
     : OutputExecuteJob(parent)
 {
     setCapabilities(Killable);
     setFilteringStrategy(OutputModel::CompilerFilter);
     setProperties(NeedWorkingDirectory | PortableMessages | DisplayStderr | IsBuilderHint);
     setToolTitle(i18n("QMake"));
     setStandardToolView(IOutputView::BuildView);
     setBehaviours(IOutputView::AllowUserClose | IOutputView::AutoScroll );
 }
 
 void QMakeJob::start()
 {
     qCDebug(KDEV_QMAKE) << "Running qmake in" << workingDirectory();
 
     if (!m_project) {
         setError(NoProjectError);
         setErrorText(i18n("No project specified."));
         return emitResult();
     }
 
     // create build directory if it does not exist yet
     QDir::temp().mkpath(workingDirectory().toLocalFile());
 
     OutputExecuteJob::start();
 }
 
 QUrl QMakeJob::workingDirectory() const
 {
     if (!m_project) {
         return QUrl();
     }
 
     return QMakeConfig::buildDirFromSrc(m_project, m_project->path()).toUrl();
 }
 
 QStringList QMakeJob::commandLine() const
 {
     if (!m_project) {
         return {};
     }
 
     QStringList args;
     args << QMakeConfig::qmakeExecutable(m_project);
 
     args << m_project->path().toUrl().toLocalFile();
 
     return args;
 }
 
 void QMakeJob::setProject(KDevelop::IProject* project)
 {
     m_project = project;
 
     if (m_project)
         setObjectName(i18n("QMake: %1", m_project->name()));
 }
 
 void QMakeJob::slotFailed(QProcess::ProcessError error)
 {
-    qDebug() << error;
+    qCDebug(KDEV_QMAKE) << error;
 
     if (!m_killed) {
         setError(ConfigureError);
         // FIXME need more detail i guess
         setErrorText(i18n("Configure error"));
     }
     emitResult();
 }
 
 void QMakeJob::slotCompleted(int code)
 {
     if (code != 0) {
         setError(FailedShownError);
     }
     emitResult();
 }
 
 bool QMakeJob::doKill()
 {
     m_killed = true;
     m_cmd->kill();
     return true;
 }
diff --git a/projectmanagers/cmake/cmakemanager.cpp b/projectmanagers/cmake/cmakemanager.cpp
index b511a05e52..6af8ae5814 100644
--- a/projectmanagers/cmake/cmakemanager.cpp
+++ b/projectmanagers/cmake/cmakemanager.cpp
@@ -1,948 +1,948 @@
 /* KDevelop CMake Support
  *
  * Copyright 2006 Matt Rogers <mattr@kde.org>
  * Copyright 2007-2013 Aleix Pol <aleixpol@kde.org>
  *
  * 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 "cmakemanager.h"
 #include "cmakeedit.h"
 #include "cmakeutils.h"
 #include "cmakeprojectdata.h"
 #include "duchain/cmakeparsejob.h"
 #include "cmakeimportjsonjob.h"
 #include "debug.h"
 #include "settings/cmakepreferences.h"
 #include <projectmanagers/custommake/makefileresolver/makefileresolver.h>
 #include "cmakecodecompletionmodel.h"
 #include "cmakenavigationwidget.h"
 #include "icmakedocumentation.h"
 #include "cmakemodelitems.h"
 #include "testing/ctestutils.h"
 #include "cmakeserverimportjob.h"
 #include "cmakeserver.h"
 
 #include <QDir>
 #include <QReadWriteLock>
 #include <QThread>
 #include <QFileSystemWatcher>
 #include <QTimer>
 
 #include <KPluginFactory>
 #include <QUrl>
 #include <QAction>
 #include <KMessageBox>
 #include <ktexteditor/document.h>
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <interfaces/iplugincontroller.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/context.h>
 #include <interfaces/idocumentation.h>
 #include <util/executecompositejob.h>
 #include <language/highlighting/codehighlighting.h>
 #include <project/projectmodel.h>
 #include <project/helper.h>
 #include <project/interfaces/iprojectbuilder.h>
 #include <project/projectfiltermanager.h>
 #include <language/codecompletion/codecompletion.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/use.h>
 #include <language/duchain/duchain.h>
 
 Q_DECLARE_METATYPE(KDevelop::IProject*);
 
 using namespace KDevelop;
 
 K_PLUGIN_FACTORY_WITH_JSON(CMakeSupportFactory, "kdevcmakemanager.json", registerPlugin<CMakeManager>(); )
 
 const QString DIALOG_CAPTION = i18n("KDevelop - CMake Support");
 
 CMakeManager::CMakeManager( QObject* parent, const QVariantList& )
     : KDevelop::AbstractFileManagerPlugin( QStringLiteral("kdevcmakemanager"), parent )
     , m_filter( new ProjectFilterManager( this ) )
 {
     if (CMake::findExecutable().isEmpty()) {
         setErrorDescription(i18n("Unable to find a CMake executable. Is one installed on the system?"));
         m_highlight = nullptr;
         return;
     }
 
     m_highlight = new KDevelop::CodeHighlighting(this);
 
     new CodeCompletion(this, new CMakeCodeCompletionModel(this), name());
 
     connect(ICore::self()->projectController(), &IProjectController::projectClosing, this, &CMakeManager::projectClosing);
     connect(this, &KDevelop::AbstractFileManagerPlugin::folderAdded, this, &CMakeManager::folderAdded);
 
 //     m_fileSystemChangeTimer = new QTimer(this);
 //     m_fileSystemChangeTimer->setSingleShot(true);
 //     m_fileSystemChangeTimer->setInterval(100);
 //     connect(m_fileSystemChangeTimer,SIGNAL(timeout()),SLOT(filesystemBuffererTimeout()));
 }
 
 CMakeManager::~CMakeManager()
 {
     parseLock()->lockForWrite();
     // By locking the parse-mutexes, we make sure that parse jobs get a chance to finish in a good state
     parseLock()->unlock();
 }
 
 bool CMakeManager::hasBuildInfo(ProjectBaseItem* item) const
 {
     return m_projects[item->project()].compilationData.files.contains(item->path());
 }
 
 Path CMakeManager::buildDirectory(KDevelop::ProjectBaseItem *item) const
 {
 //     CMakeFolderItem *fi=dynamic_cast<CMakeFolderItem*>(item);
 //     Path ret;
 //     ProjectBaseItem* parent = fi ? fi->formerParent() : item->parent();
 //     if (parent)
 //         ret=buildDirectory(parent);
 //     else
 //         ret=Path(CMake::currentBuildDir(item->project()));
 //
 //     if(fi)
 //         ret.addPath(fi->buildDir());
 //     return ret;
     return Path(CMake::currentBuildDir(item->project()));
 }
 
 KDevelop::ProjectFolderItem* CMakeManager::import( KDevelop::IProject *project )
 {
     CMake::checkForNeedingConfigure(project);
 
     return AbstractFileManagerPlugin::import(project);
 }
 
 class ChooseCMakeInterfaceJob : public ExecuteCompositeJob
 {
     Q_OBJECT
 public:
     ChooseCMakeInterfaceJob(IProject* project, CMakeManager* manager)
         : ExecuteCompositeJob(manager, {})
         , project(project)
         , manager(manager)
     {
     }
 
     void start() override {
         server = new CMakeServer(project);
         connect(server, &CMakeServer::connected, this, &ChooseCMakeInterfaceJob::successfulConnection);
         connect(server, &CMakeServer::finished, this, &ChooseCMakeInterfaceJob::failedConnection);
     }
 
 private:
     void successfulConnection() {
         auto job = new CMakeServerImportJob(project, server, this);
         connect(job, &CMakeServerImportJob::result, this, [this, job](){
             if (job->error() == 0) {
                 manager->integrateData(job->projectData(), job->project());
             }
         });
         addSubjob(job);
         ExecuteCompositeJob::start();
     }
 
     void failedConnection(int code) {
         Q_ASSERT(code > 0);
         Q_ASSERT(!server->isServerAvailable());
 
         server->deleteLater();
         server = nullptr;
 
         // parse the JSON file
         CMakeImportJsonJob* job = new CMakeImportJsonJob(project, this);
 
         // create the JSON file if it doesn't exist
         auto commandsFile = CMake::commandsFile(project);
         if (!QFileInfo::exists(commandsFile.toLocalFile())) {
             qCDebug(CMAKE) << "couldn't find commands file:" << commandsFile << "- now trying to reconfigure";
             addSubjob(manager->builder()->configure(project));
         }
 
         connect(job, &CMakeImportJsonJob::result, this, [this, job](){
             if (job->error() == 0) {
                 manager->integrateData(job->projectData(), job->project());
             }
         });
         addSubjob(job);
         ExecuteCompositeJob::start();
     }
 
     CMakeServer* server = nullptr;
     IProject* const project;
     CMakeManager* const manager;
 };
 
 KJob* CMakeManager::createImportJob(ProjectFolderItem* item)
 {
     auto project = item->project();
 
     auto job = new ChooseCMakeInterfaceJob(project, this);
     connect(job, &KJob::result, this, [this, job, project](){
         if (job->error() != 0) {
             qCWarning(CMAKE) << "couldn't load project successfully" << project->name();
             m_projects.remove(project);
         }
     });
 
     const QList<KJob*> jobs = {
         job,
         KDevelop::AbstractFileManagerPlugin::createImportJob(item) // generate the file system listing
     };
 
     Q_ASSERT(!jobs.contains(nullptr));
     ExecuteCompositeJob* composite = new ExecuteCompositeJob(this, jobs);
 //     even if the cmake call failed, we want to load the project so that the project can be worked on
     composite->setAbortOnError(false);
     return composite;
 }
 
 // QList<ProjectFolderItem*> CMakeManager::parse(ProjectFolderItem*)
 // { return QList< ProjectFolderItem* >(); }
 //
 //
 
 QList<KDevelop::ProjectTargetItem*> CMakeManager::targets() const
 {
     QList<KDevelop::ProjectTargetItem*> ret;
     foreach(IProject* p, m_projects.keys())
     {
         ret+=p->projectItem()->targetList();
     }
     return ret;
 }
 
 CMakeFile CMakeManager::fileInformation(KDevelop::ProjectBaseItem* item) const
 {
     const auto & data = m_projects[item->project()].compilationData;
     QHash<KDevelop::Path, CMakeFile>::const_iterator it = data.files.constFind(item->path());
 
     if (it == data.files.constEnd()) {
         // if the item path contains a symlink, then we will not find it in the lookup table
         // as that only only stores canonicalized paths. Thus, we fallback to
         // to the canonicalized path and see if that brings up any matches
         const auto canonicalized = Path(QFileInfo(item->path().toLocalFile()).canonicalFilePath());
         it = data.files.constFind(canonicalized);
     }
 
     if (it != data.files.constEnd()) {
         return *it;
     } else {
         // otherwise look for siblings and use the include paths of any we find
         const Path folder = item->folder() ? item->path() : item->path().parent();
 
         for( it = data.files.constBegin(); it != data.files.constEnd(); ++it) {
             if (folder.isDirectParentOf(it.key())) {
                 return *it;
             }
         }
     }
 
     // last-resort fallback: bubble up the parent chain, and keep looking for include paths
     if (auto parent = item->parent()) {
         return fileInformation(parent);
     }
 
     return {};
 }
 
 Path::List CMakeManager::includeDirectories(KDevelop::ProjectBaseItem *item) const
 {
     return fileInformation(item).includes;
 }
 
 Path::List CMakeManager::frameworkDirectories(KDevelop::ProjectBaseItem *item) const
 {
     return fileInformation(item).frameworkDirectories;
 }
 
 QHash<QString, QString> CMakeManager::defines(KDevelop::ProjectBaseItem *item ) const
 {
     return fileInformation(item).defines;
 }
 
 KDevelop::IProjectBuilder * CMakeManager::builder() const
 {
     IPlugin* i = core()->pluginController()->pluginForExtension( QStringLiteral("org.kdevelop.IProjectBuilder"), QStringLiteral("KDevCMakeBuilder"));
     Q_ASSERT(i);
     KDevelop::IProjectBuilder* _builder = i->extension<KDevelop::IProjectBuilder>();
     Q_ASSERT(_builder );
     return _builder ;
 }
 
 bool CMakeManager::reload(KDevelop::ProjectFolderItem* folder)
 {
     qCDebug(CMAKE) << "reloading" << folder->path();
 
     IProject* project = folder->project();
     if (!project->isReady())
         return false;
 
     KJob *job = createImportJob(folder);
     project->setReloadJob(job);
     ICore::self()->runController()->registerJob( job );
     return true;
 }
 
 static void populateTargets(ProjectFolderItem* folder, const QHash<KDevelop::Path, QStringList>& targets)
 {
     QStringList dirTargets = targets[folder->path()];
 
     foreach (ProjectTargetItem* item, folder->targetList()) {
         if(!dirTargets.contains(item->text())) {
             delete item;
         } else {
             dirTargets.removeAll(item->text());
         }
     }
 
     static QSet<QString> standardTargets = {
         QStringLiteral("edit_cache"), QStringLiteral("rebuild_cache"),
         QStringLiteral("list_install_components"),
         QStringLiteral("test"), //not really standard, but applicable for make and ninja
         QStringLiteral("install")
 
     };
 
     foreach (const QString& name, dirTargets) {
         if (!name.endsWith(QLatin1String("_automoc"))
             && !standardTargets.contains(name)
             && !name.startsWith(QLatin1String("install/"))
         )
             new CMakeTargetItem(folder, name);
     }
 
     foreach (ProjectFolderItem* children, folder->folderList()) {
         populateTargets(children, targets);
     }
 }
 
 void CMakeManager::integrateData(const CMakeProjectData &data, KDevelop::IProject* project)
 {
     if (data.m_server) {
         connect(data.m_server.data(), &CMakeServer::response, project, [this, project](const QJsonObject& response) {
             serverResponse(project, response);
         });
     } else {
         connect(data.watcher.data(), &QFileSystemWatcher::fileChanged, this, &CMakeManager::dirtyFile);
         connect(data.watcher.data(), &QFileSystemWatcher::directoryChanged, this, &CMakeManager::dirtyFile);
     }
     m_projects[project] = data;
 
     populateTargets(project->projectItem(), data.targets);
     CTestUtils::createTestSuites(data.m_testSuites, project);
 }
 
 void CMakeManager::serverResponse(KDevelop::IProject* project, const QJsonObject& response)
 {
     if (response[QStringLiteral("type")] == QLatin1String("signal")) {
         if (response[QStringLiteral("name")] == QLatin1String("dirty")) {
             m_projects[project].m_server->configure({});
         } else
-            qDebug() << "unhandled signal response..." << project << response;
+            qCDebug(CMAKE) << "unhandled signal response..." << project << response;
     } else if (response[QStringLiteral("type")] == QLatin1String("reply")) {
         const auto inReplyTo = response[QStringLiteral("inReplyTo")];
         if (inReplyTo == QLatin1String("configure")) {
             m_projects[project].m_server->compute();
         } else if (inReplyTo == QLatin1String("compute")) {
             m_projects[project].m_server->codemodel();
         } else if(inReplyTo == QLatin1String("codemodel")) {
             auto &data = m_projects[project];
             CMakeServerImportJob::processFileData(response, data);
             populateTargets(project->projectItem(), data.targets);
         } else {
-            qDebug() << "unhandled reply response..." << project << response;
+            qCDebug(CMAKE) << "unhandled reply response..." << project << response;
         }
     } else {
-        qDebug() << "unhandled response..." << project << response;
+        qCDebug(CMAKE) << "unhandled response..." << project << response;
     }
 }
 
 // void CMakeManager::deletedWatchedDirectory(IProject* p, const QUrl &dir)
 // {
 //     if(p->folder().equals(dir, QUrl::CompareWithoutTrailingSlash)) {
 //         ICore::self()->projectController()->closeProject(p);
 //     } else {
 //         if(dir.fileName()=="CMakeLists.txt") {
 //             QList<ProjectFolderItem*> folders = p->foldersForUrl(dir.upUrl());
 //             foreach(ProjectFolderItem* folder, folders)
 //                 reload(folder);
 //         } else {
 //             qDeleteAll(p->itemsForUrl(dir));
 //         }
 //     }
 // }
 
 // void CMakeManager::directoryChanged(const QString& dir)
 // {
 //     m_fileSystemChangedBuffer << dir;
 //     m_fileSystemChangeTimer->start();
 // }
 
 // void CMakeManager::filesystemBuffererTimeout()
 // {
 //     Q_FOREACH(const QString& file, m_fileSystemChangedBuffer) {
 //         realDirectoryChanged(file);
 //     }
 //     m_fileSystemChangedBuffer.clear();
 // }
 
 // void CMakeManager::realDirectoryChanged(const QString& dir)
 // {
 //     QUrl path(dir);
 //     IProject* p=ICore::self()->projectController()->findProjectForUrl(dir);
 //     if(!p || !p->isReady()) {
 //         if(p) {
 //             m_fileSystemChangedBuffer << dir;
 //             m_fileSystemChangeTimer->start();
 //         }
 //         return;
 //     }
 //
 //     if(!QFile::exists(dir)) {
 //         path.adjustPath(QUrl::AddTrailingSlash);
 //         deletedWatchedDirectory(p, path);
 //     } else
 //         dirtyFile(dir);
 // }
 
 QList< KDevelop::ProjectTargetItem * > CMakeManager::targets(KDevelop::ProjectFolderItem * folder) const
 {
     return folder->targetList();
 }
 
 QString CMakeManager::name() const
 {
     return languageName().str();
 }
 
 IndexedString CMakeManager::languageName()
 {
     static IndexedString name("CMake");
     return name;
 }
 
 KDevelop::ParseJob * CMakeManager::createParseJob(const IndexedString &url)
 {
     return new CMakeParseJob(url, this);
 }
 
 KDevelop::ICodeHighlighting* CMakeManager::codeHighlighting() const
 {
     return m_highlight;
 }
 
 // ContextMenuExtension CMakeManager::contextMenuExtension( KDevelop::Context* context )
 // {
 //     if( context->type() != KDevelop::Context::ProjectItemContext )
 //         return IPlugin::contextMenuExtension( context );
 //
 //     KDevelop::ProjectItemContext* ctx = dynamic_cast<KDevelop::ProjectItemContext*>( context );
 //     QList<KDevelop::ProjectBaseItem*> items = ctx->items();
 //
 //     if( items.isEmpty() )
 //         return IPlugin::contextMenuExtension( context );
 //
 //     m_clickedItems = items;
 //     ContextMenuExtension menuExt;
 //     if(items.count()==1 && dynamic_cast<DUChainAttatched*>(items.first()))
 //     {
 //         QAction * action = new QAction( i18n( "Jump to Target Definition" ), this );
 //         connect( action, SIGNAL(triggered()), this, SLOT(jumpToDeclaration()) );
 //         menuExt.addAction( ContextMenuExtension::ProjectGroup, action );
 //     }
 //
 //     return menuExt;
 // }
 //
 // void CMakeManager::jumpToDeclaration()
 // {
 //     DUChainAttatched* du=dynamic_cast<DUChainAttatched*>(m_clickedItems.first());
 //     if(du)
 //     {
 //         KTextEditor::Cursor c;
 //         QUrl url;
 //         {
 //             KDevelop::DUChainReadLocker lock;
 //             Declaration* decl = du->declaration().data();
 //             if(!decl)
 //                 return;
 //             c = decl->rangeInCurrentRevision().start();
 //             url = decl->url().toUrl();
 //         }
 //
 //         ICore::self()->documentController()->openDocument(url, c);
 //     }
 // }
 //
 // // TODO: Port to Path API
 // bool CMakeManager::moveFilesAndFolders(const QList< ProjectBaseItem* > &items, ProjectFolderItem* toFolder)
 // {
 //     using namespace CMakeEdit;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Move files and folders within CMakeLists as follows:"));
 //
 //     bool cmakeSuccessful = true;
 //     CMakeFolderItem *nearestCMakeFolderItem = nearestCMakeFolder(toFolder);
 //     IProject* project=toFolder->project();
 //
 //     QList<QUrl> movedUrls;
 //     QList<QUrl> oldUrls;
 //     foreach(ProjectBaseItem *movedItem, items)
 //     {
 //         QList<ProjectBaseItem*> dirtyItems = cmakeListedItemsAffectedByUrlChange(project, movedItem->url());
 //         QUrl movedItemNewUrl = toFolder->url();
 //         movedItemNewUrl.addPath(movedItem->baseName());
 //         if (movedItem->folder())
 //             movedItemNewUrl.adjustPath(QUrl::AddTrailingSlash);
 //         foreach(ProjectBaseItem* dirtyItem, dirtyItems)
 //         {
 //             QUrl dirtyItemNewUrl = afterMoveUrl(dirtyItem->url(), movedItem->url(), movedItemNewUrl);
 //             if (CMakeFolderItem* folder = dynamic_cast<CMakeFolderItem*>(dirtyItem))
 //             {
 //                 cmakeSuccessful &= changesWidgetRemoveCMakeFolder(folder, &changesWidget);
 //                 cmakeSuccessful &= changesWidgetAddFolder(dirtyItemNewUrl, nearestCMakeFolderItem, &changesWidget);
 //             }
 //             else if (dirtyItem->parent()->target())
 //             {
 //                 cmakeSuccessful &= changesWidgetMoveTargetFile(dirtyItem, dirtyItemNewUrl, &changesWidget);
 //             }
 //         }
 //
 //         oldUrls += movedItem->url();
 //         movedUrls += movedItemNewUrl;
 //     }
 //
 //     if (changesWidget.hasDocuments() && cmakeSuccessful)
 //         cmakeSuccessful &= changesWidget.exec() && changesWidget.applyAllChanges();
 //
 //     if (!cmakeSuccessful)
 //     {
 //         if (KMessageBox::questionYesNo( QApplication::activeWindow(),
 //                                         i18n("Changes to CMakeLists failed, abort move?"),
 //                                         DIALOG_CAPTION ) == KMessageBox::Yes)
 //             return false;
 //     }
 //
 //     QList<QUrl>::const_iterator it1=oldUrls.constBegin(), it1End=oldUrls.constEnd();
 //     QList<QUrl>::const_iterator it2=movedUrls.constBegin();
 //     Q_ASSERT(oldUrls.size()==movedUrls.size());
 //     for(; it1!=it1End; ++it1, ++it2)
 //     {
 //         if (!KDevelop::renameUrl(project, *it1, *it2))
 //             return false;
 //
 //         QList<ProjectBaseItem*> renamedItems = project->itemsForUrl(*it2);
 //         bool dir = QFileInfo(it2->toLocalFile()).isDir();
 //         foreach(ProjectBaseItem* item, renamedItems) {
 //             if(dir)
 //                 emit folderRenamed(Path(*it1), item->folder());
 //             else
 //                 emit fileRenamed(Path(*it1), item->file());
 //         }
 //     }
 //
 //     return true;
 // }
 //
 // bool CMakeManager::copyFilesAndFolders(const KDevelop::Path::List &items, KDevelop::ProjectFolderItem* toFolder)
 // {
 //     IProject* project = toFolder->project();
 //     foreach(const Path& path, items) {
 //         if (!KDevelop::copyUrl(project, path.toUrl(), toFolder->url()))
 //             return false;
 //     }
 //
 //     return true;
 // }
 //
 // bool CMakeManager::removeFilesAndFolders(const QList<KDevelop::ProjectBaseItem*> &items)
 // {
 //     using namespace CMakeEdit;
 //
 //     IProject* p = 0;
 //     QList<QUrl> urls;
 //     foreach(ProjectBaseItem* item, items)
 //     {
 //         Q_ASSERT(item->folder() || item->file());
 //
 //         urls += item->url();
 //         if(!p)
 //             p = item->project();
 //     }
 //
 //     //First do CMakeLists changes
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Remove files and folders from CMakeLists as follows:"));
 //
 //     bool cmakeSuccessful = changesWidgetRemoveItems(cmakeListedItemsAffectedByItemsChanged(items).toSet(), &changesWidget);
 //
 //     if (changesWidget.hasDocuments() && cmakeSuccessful)
 //         cmakeSuccessful &= changesWidget.exec() && changesWidget.applyAllChanges();
 //
 //     if (!cmakeSuccessful)
 //     {
 //         if (KMessageBox::questionYesNo( QApplication::activeWindow(),
 //                                         i18n("Changes to CMakeLists failed, abort deletion?"),
 //                                         DIALOG_CAPTION ) == KMessageBox::Yes)
 //             return false;
 //     }
 //
 //     bool ret = true;
 //     //Then delete the files/folders
 //     foreach(const QUrl& file, urls)
 //     {
 //         ret &= KDevelop::removeUrl(p, file, QDir(file.toLocalFile()).exists());
 //     }
 //
 //     return ret;
 // }
 
 bool CMakeManager::removeFilesFromTargets(const QList<ProjectFileItem*> &/*files*/)
 {
 //     using namespace CMakeEdit;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Modify project targets as follows:"));
 //
 //     if (!files.isEmpty() &&
 //         changesWidgetRemoveFilesFromTargets(files, &changesWidget) &&
 //         changesWidget.exec() &&
 //         changesWidget.applyAllChanges()) {
 //         return true;
 //     }
     return false;
 }
 
 // ProjectFolderItem* CMakeManager::addFolder(const Path& folder, ProjectFolderItem* parent)
 // {
 //     using namespace CMakeEdit;
 //
 //     CMakeFolderItem *cmakeParent = nearestCMakeFolder(parent);
 //     if(!cmakeParent)
 //         return 0;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Create folder '%1':", folder.lastPathSegment()));
 //
 //     ///FIXME: use path in changes widget
 //     changesWidgetAddFolder(folder.toUrl(), cmakeParent, &changesWidget);
 //
 //     if(changesWidget.exec() && changesWidget.applyAllChanges())
 //     {
 //         if(KDevelop::createFolder(folder.toUrl())) { //If saved we create the folder then the CMakeLists.txt file
 //             Path newCMakeLists(folder, "CMakeLists.txt");
 //             KDevelop::createFile( newCMakeLists.toUrl() );
 //         } else
 //             KMessageBox::error(0, i18n("Could not save the change."),
 //                                   DIALOG_CAPTION);
 //     }
 //
 //     return 0;
 // }
 //
 // KDevelop::ProjectFileItem* CMakeManager::addFile( const Path& file, KDevelop::ProjectFolderItem* parent)
 // {
 //     KDevelop::ProjectFileItem* created = 0;
 //     if ( KDevelop::createFile(file.toUrl()) ) {
 //         QList< ProjectFileItem* > files = parent->project()->filesForPath(IndexedString(file.pathOrUrl()));
 //         if(!files.isEmpty())
 //             created = files.first();
 //         else
 //             created = new KDevelop::ProjectFileItem( parent->project(), file, parent );
 //     }
 //     return created;
 // }
 
 bool CMakeManager::addFilesToTarget(const QList< ProjectFileItem* > &/*_files*/, ProjectTargetItem* /*target*/)
 {
     return false;
 //     using namespace CMakeEdit;
 //
 //     const QSet<QString> headerExt = QSet<QString>() << ".h" << ".hpp" << ".hxx";
 //     QList< ProjectFileItem* > files = _files;
 //     for (int i = files.count() - 1; i >= 0; --i)
 //     {
 //         QString fileName = files[i]->fileName();
 //         QString fileExt = fileName.mid(fileName.lastIndexOf('.'));
 //         QList<ProjectBaseItem*> sameUrlItems = files[i]->project()->itemsForUrl(files[i]->url());
 //         if (headerExt.contains(fileExt))
 //             files.removeAt(i);
 //         else foreach(ProjectBaseItem* item, sameUrlItems)
 //         {
 //             if (item->parent() == target)
 //             {
 //                 files.removeAt(i);
 //                 break;
 //             }
 //         }
 //     }
 //
 //     if(files.isEmpty())
 //         return true;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Modify target '%1' as follows:", target->baseName()));
 //
 //     bool success = changesWidgetAddFilesToTarget(files, target, &changesWidget) &&
 //                    changesWidget.exec() &&
 //                    changesWidget.applyAllChanges();
 //
 //     if(!success)
 //         KMessageBox::error(0, i18n("CMakeLists changes failed."), DIALOG_CAPTION);
 //
 //     return success;
 }
 
 // bool CMakeManager::renameFileOrFolder(ProjectBaseItem *item, const Path &newPath)
 // {
 //     using namespace CMakeEdit;
 //
 //     ApplyChangesWidget changesWidget;
 //     changesWidget.setCaption(DIALOG_CAPTION);
 //     changesWidget.setInformation(i18n("Rename '%1' to '%2':", item->text(),
 //                                       newPath.lastPathSegment()));
 //
 //     bool cmakeSuccessful = true, changedCMakeLists=false;
 //     IProject* project=item->project();
 //     const Path oldPath=item->path();
 //     QUrl oldUrl=oldPath.toUrl();
 //     if (item->file())
 //     {
 //         QList<ProjectBaseItem*> targetFiles = cmakeListedItemsAffectedByUrlChange(project, oldUrl);
 //         foreach(ProjectBaseItem* targetFile, targetFiles)
 //             ///FIXME: use path in changes widget
 //             cmakeSuccessful &= changesWidgetMoveTargetFile(targetFile, newPath.toUrl(), &changesWidget);
 //     }
 //     else if (CMakeFolderItem *folder = dynamic_cast<CMakeFolderItem*>(item))
 //         ///FIXME: use path in changes widget
 //         cmakeSuccessful &= changesWidgetRenameFolder(folder, newPath.toUrl(), &changesWidget);
 //
 //     item->setPath(newPath);
 //     if (changesWidget.hasDocuments() && cmakeSuccessful) {
 //         changedCMakeLists = changesWidget.exec() && changesWidget.applyAllChanges();
 //         cmakeSuccessful &= changedCMakeLists;
 //     }
 //
 //     if (!cmakeSuccessful)
 //     {
 //         if (KMessageBox::questionYesNo( QApplication::activeWindow(),
 //             i18n("Changes to CMakeLists failed, abort rename?"),
 //                                         DIALOG_CAPTION ) == KMessageBox::Yes)
 //             return false;
 //     }
 //
 //     bool ret = KDevelop::renameUrl(project, oldUrl, newPath.toUrl());
 //     if(!ret) {
 //         item->setPath(oldPath);
 //     }
 //     return ret;
 // }
 //
 // bool CMakeManager::renameFile(ProjectFileItem *item, const Path &newPath)
 // {
 //     return renameFileOrFolder(item, newPath);
 // }
 //
 // bool CMakeManager::renameFolder(ProjectFolderItem* item, const Path &newPath)
 // {
 //     return renameFileOrFolder(item, newPath);
 // }
 
 QWidget* CMakeManager::specialLanguageObjectNavigationWidget(const QUrl &url, const KTextEditor::Cursor& position)
 {
     KDevelop::TopDUContextPointer top= TopDUContextPointer(KDevelop::DUChain::self()->chainForDocument(url));
     Declaration *decl=nullptr;
     if(top)
     {
         int useAt=top->findUseAt(top->transformToLocalRevision(position));
         if(useAt>=0)
         {
             Use u=top->uses()[useAt];
             decl=u.usedDeclaration(top->topContext());
         }
     }
 
     CMakeNavigationWidget* doc=nullptr;
     if(decl)
     {
         doc=new CMakeNavigationWidget(top, decl);
     }
     else
     {
         const IDocument* d=ICore::self()->documentController()->documentForUrl(url);
         const KTextEditor::Document* e=d->textDocument();
         KTextEditor::Cursor start=position, end=position, step(0,1);
         for(QChar i=e->characterAt(start); i.isLetter() || i=='_'; i=e->characterAt(start-=step))
         {}
         start+=step;
 
         for(QChar i=e->characterAt(end); i.isLetter() || i=='_'; i=e->characterAt(end+=step))
         {}
 
         QString id=e->text(KTextEditor::Range(start, end));
         ICMakeDocumentation* docu=CMake::cmakeDocumentation();
         if( docu )
         {
             IDocumentation::Ptr desc=docu->description(id, url);
             if(desc)
             {
                 doc=new CMakeNavigationWidget(top, desc);
             }
         }
     }
 
     return doc;
 }
 
 QPair<QString, QString> CMakeManager::cacheValue(KDevelop::IProject* /*project*/, const QString& /*id*/) const
 { return QPair<QString, QString>(); }
 // {
 //     QPair<QString, QString> ret;
 //     if(project==0 && !m_projectsData.isEmpty())
 //     {
 //         project=m_projectsData.keys().first();
 //     }
 //
 // //     qCDebug(CMAKE) << "cache value " << id << project << (m_projectsData.contains(project) && m_projectsData[project].cache.contains(id));
 //     CMakeProjectData* data = m_projectsData[project];
 //     if(data && data->cache.contains(id))
 //     {
 //         const CacheEntry& e=data->cache.value(id);
 //         ret.first=e.value;
 //         ret.second=e.doc;
 //     }
 //     return ret;
 // }Add
 //
 void CMakeManager::projectClosing(IProject* p)
 {
     m_projects.remove(p);
 //     delete m_projectsData.take(p);
 //     delete m_watchers.take(p);
 //
 //     m_filter->remove(p);
 //
 //     qCDebug(CMAKE) << "Project closed" << p;
 }
 //
 // QStringList CMakeManager::processGeneratorExpression(const QStringList& expr, IProject* project, ProjectTargetItem* target) const
 // {
 //     QStringList ret;
 //     const CMakeProjectData* data = m_projectsData[project];
 //     GenerationExpressionSolver exec(data->properties, data->targetAlias);
 //     if(target)
 //         exec.setTargetName(target->text());
 //
 //     exec.defineVariable("INSTALL_PREFIX", data->vm.value("CMAKE_INSTALL_PREFIX").join(QString()));
 //     for(QStringList::const_iterator it = expr.constBegin(), itEnd = expr.constEnd(); it!=itEnd; ++it) {
 //         QStringList val = exec.run(*it).split(';');
 //         ret += val;
 //     }
 //     return ret;
 // }
 /*
 void CMakeManager::addPending(const Path& path, CMakeFolderItem* folder)
 {
     m_pending.insert(path, folder);
 }
 
 CMakeFolderItem* CMakeManager::takePending(const Path& path)
 {
     return m_pending.take(path);
 }
 
 void CMakeManager::addWatcher(IProject* p, const QString& path)
 {
     if (QFileSystemWatcher* watcher = m_watchers.value(p)) {
         watcher->addPath(path);
     } else {
-        qWarning() << "Could not find a watcher for project" << p << p->name() << ", path " << path;
+        qCWarning(CMAKE) << "Could not find a watcher for project" << p << p->name() << ", path " << path;
         Q_ASSERT(false);
     }
 }*/
 
 // CMakeProjectData CMakeManager::projectData(IProject* project)
 // {
 //     Q_ASSERT(QThread::currentThread() == project->thread());
 //     CMakeProjectData* data = m_projectsData[project];
 //     if(!data) {
 //         data = new CMakeProjectData;
 //         m_projectsData[project] = data;
 //     }
 //     return *data;
 // }
 
 ProjectFilterManager* CMakeManager::filterManager() const
 {
     return m_filter;
 }
 
 void CMakeManager::dirtyFile(const QString& path)
 {
     qCDebug(CMAKE) << "dirty!" << path;
 
     //we initialize again hte project that sent the signal
     for(QHash<IProject*, CMakeProjectData>::const_iterator it = m_projects.constBegin(), itEnd = m_projects.constEnd(); it!=itEnd; ++it) {
         if(it->watcher == sender()) {
             reload(it.key()->projectItem());
             break;
         }
     }
 }
 
 void CMakeManager::folderAdded(KDevelop::ProjectFolderItem* folder)
 {
     populateTargets(folder, m_projects[folder->project()].targets);
 }
 
 ProjectFolderItem* CMakeManager::createFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
 //     TODO: when we have data about targets, use folders with targets or similar
     if (QFile::exists(path.toLocalFile()+"/CMakeLists.txt"))
         return new KDevelop::ProjectBuildFolderItem( project, path, parent );
     else
         return KDevelop::AbstractFileManagerPlugin::createFolderItem(project, path, parent);
 }
 
 int CMakeManager::perProjectConfigPages() const
 {
     return 1;
 }
 
 ConfigPage* CMakeManager::perProjectConfigPage(int number, const ProjectConfigOptions& options, QWidget* parent)
 {
     if (number == 0) {
         return new CMakePreferences(this, options, parent);
     }
     return nullptr;
 }
 
 #include "cmakemanager.moc"
diff --git a/projectmanagers/cmake/cmakeserver.cpp b/projectmanagers/cmake/cmakeserver.cpp
index 9f52fc711f..5d52b0c3ce 100644
--- a/projectmanagers/cmake/cmakeserver.cpp
+++ b/projectmanagers/cmake/cmakeserver.cpp
@@ -1,198 +1,198 @@
 /* KDevelop CMake Support
  *
  * Copyright 2017 Aleix Pol <aleixpol@kde.org>
  *
  * 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 "cmakeserver.h"
 #include "cmakeprojectdata.h"
 #include "cmakeutils.h"
 #include <QDir>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QTimer>
 #include <QTemporaryFile>
 #include "debug.h"
 
 CMakeServer::CMakeServer(QObject* parent)
     : QObject(parent)
     , m_localSocket(new QLocalSocket(this))
 {
     QString path;
     {
         QTemporaryFile file(QDir::tempPath() + "/kdevelopcmake-");
         file.open();
         file.close();
         path = file.fileName();
     }
 
     m_process.setProcessChannelMode(QProcess::ForwardedChannels);
 
 #if QT_VERSION < 0x050600
     connect(&m_process, static_cast<void(QProcess::*)(QProcess::ProcessError)>(&QProcess::error),
 #else
     connect(&m_process, &QProcess::errorOccurred,
 #endif
             this, [this, path](QProcess::ProcessError error) {
         qCWarning(CMAKE) << "cmake server error:" << error << path << m_process.readAllStandardError() << m_process.readAllStandardOutput();
     });
     connect(&m_process, static_cast<void(QProcess::*)(int)>(&QProcess::finished), this, [](int code){
         qCDebug(CMAKE) << "cmake server finished with code" << code;
     });
     connect(&m_process, static_cast<void(QProcess::*)(int)>(&QProcess::finished), this, &CMakeServer::finished);
 
     connect(m_localSocket, &QIODevice::readyRead, this, &CMakeServer::processOutput);
     connect(m_localSocket, static_cast<void(QLocalSocket::*)(QLocalSocket::LocalSocketError)>(&QLocalSocket::error), this, [this, path](QLocalSocket::LocalSocketError socketError) {
         qCWarning(CMAKE) << "cmake server socket error:" << socketError << path;
         setConnected(false);
     });
     connect(m_localSocket, &QLocalSocket::connected, this, [this]() { setConnected(true); });
 
     connect(&m_process, &QProcess::started, this, [this, path](){
         //Once the process has started, wait for the file to be created, then connect to it
         m_localSocket->connectToServer(path, QIODevice::ReadWrite);
         QTimer::singleShot(100, this, [this, path]() {
             if (!m_localSocket->isOpen())
                 m_localSocket->connectToServer(path, QIODevice::ReadWrite);
         });
     });
     m_process.start(CMake::findExecutable(), {"-E", "server", "--experimental", "--pipe=" + path});
 }
 
 CMakeServer::~CMakeServer()
 {
     m_process.kill();
     m_process.waitForFinished();
 }
 
 void CMakeServer::setConnected(bool conn)
 {
     if (conn == m_connected)
         return;
 
     m_connected = conn;
     if (m_connected)
         Q_EMIT connected();
     else
         Q_EMIT disconnected();
 }
 
 bool CMakeServer::isServerAvailable()
 {
     return m_localSocket->isOpen();
 }
 
 static QByteArray openTag() { return QByteArrayLiteral("\n[== \"CMake Server\" ==[\n"); }
 static QByteArray closeTag() { return QByteArrayLiteral("\n]== \"CMake Server\" ==]\n"); }
 
 void CMakeServer::sendCommand(const QJsonObject& object)
 {
     Q_ASSERT(isServerAvailable());
 
     const QByteArray data = openTag() + QJsonDocument(object).toJson(QJsonDocument::Compact) + closeTag();
     auto len = m_localSocket->write(data);
 //     qCDebug(CMAKE) << "writing...\n" << QJsonDocument(object).toJson();
     Q_ASSERT(len > 0);
 }
 
 void CMakeServer::processOutput()
 {
     Q_ASSERT(m_localSocket);
 
     const auto openTag = ::openTag();
     const auto closeTag = ::closeTag();
 
     m_buffer += m_localSocket->readAll();
     for(; m_buffer.size() > openTag.size(); ) {
 
         Q_ASSERT(m_buffer.startsWith(openTag));
         const int idx = m_buffer.indexOf(closeTag, openTag.size());
         if (idx >= 0) {
             emitResponse(m_buffer.mid(openTag.size(), idx - openTag.size()));
             m_buffer = m_buffer.mid(idx + closeTag.size());
         } else {
             break;
         }
     }
 }
 
 void CMakeServer::emitResponse(const QByteArray& data)
 {
     QJsonParseError error;
     auto doc = QJsonDocument::fromJson(data, &error);
     if (error.error) {
         qCWarning(CMAKE) << "error processing" << error.errorString() << data;
     }
     Q_ASSERT(doc.isObject());
     Q_EMIT response(doc.object());
 }
 
 void CMakeServer::handshake(const KDevelop::Path& source, const KDevelop::Path& build)
 {
     Q_ASSERT(!source.isEmpty());
 
     const QString generatorVariable = QStringLiteral("CMAKE_GENERATOR");
     const QString homeDirectoryVariable = QStringLiteral("CMAKE_HOME_DIRECTORY");
     const auto cacheValues = CMake::readCacheValues(KDevelop::Path(build, QStringLiteral("CMakeCache.txt")),
                                                     {generatorVariable, homeDirectoryVariable});
 
     QString generator = cacheValues.value(generatorVariable);
     if (generator.isEmpty()) {
         generator = CMake::defaultGenerator();
     }
 
     // prefer pre-existing source directory, see also: https://gitlab.kitware.com/cmake/cmake/issues/16736
     QString sourceDirectory = cacheValues.value(homeDirectoryVariable);
     if (sourceDirectory.isEmpty()) {
         sourceDirectory = source.toLocalFile();
     } else if (QFileInfo(sourceDirectory).canonicalFilePath() != QFileInfo(source.toLocalFile()).canonicalFilePath()) {
-        qWarning() << "Build directory is configured for another source directory:"
+        qCWarning(CMAKE) << "Build directory is configured for another source directory:"
                    << homeDirectoryVariable << sourceDirectory
                    << "wanted to open" << source << "in" << build;
     }
 
     qCDebug(CMAKE) << "Using generator" << generator << "for project" << source << "in" << build;
 
     sendCommand({
         {"cookie", {}},
         {"type", "handshake"},
         {"major", 1},
         {"protocolVersion", QJsonObject{{"major", 1}} },
         {"sourceDirectory", sourceDirectory},
         {"buildDirectory", build.toLocalFile()},
         {"generator", generator} //TODO: make it possible to keep whatever they have ATM
     });
 }
 
 void CMakeServer::configure(const QStringList& args)
 {
     sendCommand({
         {"type", "configure"},
         {"cacheArguments", QJsonArray::fromStringList(args)}
     });
 }
 
 void CMakeServer::compute()
 {
     sendCommand({ {"type", "compute"} });
 }
 
 void CMakeServer::codemodel()
 {
     sendCommand({ {"type", "codemodel"} });
 }
diff --git a/projectmanagers/cmake/cmakeserverimportjob.cpp b/projectmanagers/cmake/cmakeserverimportjob.cpp
index 1a4ebf9c93..398ca692c4 100644
--- a/projectmanagers/cmake/cmakeserverimportjob.cpp
+++ b/projectmanagers/cmake/cmakeserverimportjob.cpp
@@ -1,180 +1,180 @@
 /* KDevelop CMake Support
  *
  * Copyright 2017 Aleix Pol Gonzalez <aleixpol@kde.org>
  *
  * 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 "cmakeserverimportjob.h"
 #include "cmakeutils.h"
 #include "cmakeserver.h"
 
 #include <interfaces/iproject.h>
 #include <projectmanagers/custommake/makefileresolver/makefileresolver.h>
 
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QRegularExpression>
 #include <QFileInfo>
 
 #include "debug.h"
 
 
 template <typename T, typename Q, typename W>
 static T kTransform(const Q& list, W func)
 {
     T ret;
     ret.reserve(list.size());
     for (auto it = list.constBegin(), itEnd = list.constEnd(); it!=itEnd; ++it)
         ret += func(*it);
     return ret;
 }
 
 static QString unescape(const QStringRef& input)
 {
   QString output;
   output.reserve(input.length());
   bool isEscaped = false;
   for (auto it = input.data(), end = it + input.length(); it != end; ++it) {
     QChar c = *it;
     if (!isEscaped && c == '\\') {
       isEscaped = true;
     } else {
       output.append(c);
       isEscaped = false;
     }
   }
   return output;
 }
 
 static QHash<QString, QString> processDefines(const QString &compileFlags, const QJsonArray &defines)
 {
     QHash<QString, QString> ret;
     const auto& defineRx = MakeFileResolver::defineRegularExpression();
     auto it = defineRx.globalMatch(compileFlags);
     while (it.hasNext()) {
       const auto match = it.next();
       QString value;
       if (match.lastCapturedIndex() > 1) {
         value = unescape(match.capturedRef(match.lastCapturedIndex()));
       }
       ret[match.captured(1)] = value;
     }
 
     for (const QJsonValue& defineValue: defines) {
         const QString define = defineValue.toString();
         const int eqIdx = define.indexOf(QLatin1Char('='));
         if (eqIdx<0) {
             ret[define] = QString();
         } else {
             ret[define.left(eqIdx)] = define.mid(eqIdx+1);
         }
     }
     return ret;
 }
 
 void CMakeServerImportJob::processFileData(const QJsonObject &response, CMakeProjectData &data)
 {
     const auto configs = response.value(QStringLiteral("configurations")).toArray();
     qCDebug(CMAKE) << "process response" << response;
     for (const auto &config: configs) {
         const auto projects = config.toObject().value(QStringLiteral("projects")).toArray();
         for (const auto &project: projects) {
             const auto targets = project.toObject().value(QStringLiteral("targets")).toArray();
             for (const auto &targetObject: targets) {
                 const auto target = targetObject.toObject();
                 const KDevelop::Path targetDir(target.value(QStringLiteral("sourceDirectory")).toString());
 
                 data.targets[targetDir] += target.value(QStringLiteral("name")).toString();
 
                 const auto fileGroups = target.value(QStringLiteral("fileGroups")).toArray();
                 for (const auto &fileGroupValue: fileGroups) {
                     const auto fileGroup = fileGroupValue.toObject();
                     CMakeFile file;
                     file.includes = kTransform<KDevelop::Path::List>(fileGroup.value(QStringLiteral("includePath")).toArray(), [](const QJsonValue& val) { return KDevelop::Path(val.toObject().value(QStringLiteral("path")).toString()); });
                     file.defines = processDefines(fileGroup.value(QStringLiteral("compileFlags")).toString(), fileGroup.value(QStringLiteral("defines")).toArray());
 
                     const auto sourcesArray = fileGroup.value(QStringLiteral("sources")).toArray();
                     const KDevelop::Path::List sources = kTransform<KDevelop::Path::List>(sourcesArray, [targetDir](const QJsonValue& val) { return KDevelop::Path(targetDir, val.toString()); });
                     for (const auto& source: sources) {
                         // NOTE: we use the canonical file path to prevent issues with symlinks in the path
                         //       leading to lookup failures
                         const auto localFile = source.toLocalFile();
                         const auto canonicalFile = QFileInfo(source.toLocalFile()).canonicalFilePath();
                         const auto sourcePath = localFile == canonicalFile ? source : KDevelop::Path(canonicalFile);
                         data.compilationData.files[sourcePath] = file;
                     }
                     qCDebug(CMAKE) << "registering..." << sources << file;
                 }
             }
         }
     }
 }
 
 CMakeServerImportJob::CMakeServerImportJob(KDevelop::IProject* project, CMakeServer* server, QObject* parent)
     : KJob(parent)
     , m_server(server)
     , m_project(project)
 {
     connect(m_server.data(), &CMakeServer::disconnected, this, [this]() {
         setError(UnexpectedDisconnect);
         emitResult();
     });
 }
 
 void CMakeServerImportJob::start()
 {
     if (m_server->isServerAvailable())
         doStart();
     else
         connect(m_server.data(), &CMakeServer::connected, this, &CMakeServerImportJob::doStart);
 }
 
 void CMakeServerImportJob::doStart()
 {
     connect(m_server.data(), &CMakeServer::response, this, &CMakeServerImportJob::processResponse);
 
     m_server->handshake(m_project->path(), CMake::currentBuildDir(m_project));
 }
 
 void CMakeServerImportJob::processResponse(const QJsonObject& response)
 {
     const auto responseType = response.value(QStringLiteral("type"));
     if (responseType == QLatin1String("reply")) {
         const auto inReplyTo = response.value(QStringLiteral("inReplyTo"));
         qCDebug(CMAKE) << "replying..." << inReplyTo;
         if (inReplyTo == QLatin1String("handshake")) {
             m_server->configure({});
         } else if (inReplyTo == QLatin1String("configure")) {
             m_server->compute();
         } else if (inReplyTo == QLatin1String("compute")) {
             m_server->codemodel();
         } else if(inReplyTo == QLatin1String("codemodel")) {
             processFileData(response, m_data);
             m_data.m_server = m_server;
             emitResult();
         } else {
-            qWarning() << "unhandled reply" << response;
+            qCWarning(CMAKE) << "unhandled reply" << response;
         }
     } else if(responseType == QLatin1String("error")) {
         setError(ErrorResponse);
         setErrorText(response.value(QStringLiteral("errorMessage")).toString());
-        qWarning() << "error!!" << response;
+        qCWarning(CMAKE) << "error!!" << response;
         emitResult();
     } else {
-        qWarning() << "unhandled message" << response;
+        qCWarning(CMAKE) << "unhandled message" << response;
     }
 }
diff --git a/projectmanagers/cmake/cmakeutils.cpp b/projectmanagers/cmake/cmakeutils.cpp
index 0b66f42b43..1addc3cb06 100644
--- a/projectmanagers/cmake/cmakeutils.cpp
+++ b/projectmanagers/cmake/cmakeutils.cpp
@@ -1,637 +1,637 @@
 /* KDevelop CMake Support
  *
  * Copyright 2009 Andreas Pakulat <apaku@gmx.de>
  *
  * 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 "cmakeutils.h"
 
 #include <QFileInfo>
 #include <QDir>
 #include <QProcess>
 #include <QTemporaryDir>
 #include <QRegularExpression>
 
 #include <KLocalizedString>
 #include <kconfiggroup.h>
 
 #include <project/projectmodel.h>
 #include <interfaces/iproject.h>
 #include <interfaces/icore.h>
 #include <interfaces/iplugincontroller.h>
 #include <QStandardPaths>
 
 #include "icmakedocumentation.h"
 #include "cmakebuilddirchooser.h"
 #include "settings/cmakecachemodel.h"
 #include "debug.h"
 #include "cmakebuilderconfig.h"
 #include <cmakecachereader.h>
 
 using namespace KDevelop;
 
 namespace Config
 {
 namespace Old
 {
 static const QString currentBuildDirKey = QStringLiteral("CurrentBuildDir");
 static const QString currentCMakeBinaryKey = QStringLiteral("Current CMake Binary");
 static const QString currentBuildTypeKey = QStringLiteral("CurrentBuildType");
 static const QString currentInstallDirKey = QStringLiteral("CurrentInstallDir");
 static const QString currentEnvironmentKey = QStringLiteral("CurrentEnvironment");
 static const QString currentExtraArgumentsKey = QStringLiteral("Extra Arguments");
 static const QString projectRootRelativeKey = QStringLiteral("ProjectRootRelative");
 static const QString projectBuildDirs = QStringLiteral("BuildDirs");
 }
 
 static const QString buildDirIndexKey = QStringLiteral("Current Build Directory Index");
 static const QString buildDirOverrideIndexKey = QStringLiteral("Temporary Build Directory Index");
 static const QString buildDirCountKey = QStringLiteral("Build Directory Count");
 
 namespace Specific
 {
 static const QString buildDirPathKey = QStringLiteral("Build Directory Path");
 // TODO: migrate to more generic & consistent key term "CMake Executable"
 static const QString cmakeExecutableKey = QStringLiteral("CMake Binary");
 static const QString cmakeBuildTypeKey = QStringLiteral("Build Type");
 static const QString cmakeInstallDirKey = QStringLiteral("Install Directory");
 static const QString cmakeEnvironmentKey = QStringLiteral("Environment Profile");
 static const QString cmakeArgumentsKey = QStringLiteral("Extra Arguments");
 }
 
 static const QString groupNameBuildDir = QStringLiteral("CMake Build Directory %1");
 static const QString groupName = QStringLiteral("CMake");
 
 } // namespace Config
 
 namespace
 {
 
 KConfigGroup baseGroup( KDevelop::IProject* project )
 {
     if (!project)
         return KConfigGroup();
 
     return project->projectConfiguration()->group( Config::groupName );
 }
 
 KConfigGroup buildDirGroup( KDevelop::IProject* project, int buildDirIndex )
 {
     return baseGroup(project).group( Config::groupNameBuildDir.arg(buildDirIndex) );
 }
 
 bool buildDirGroupExists( KDevelop::IProject* project, int buildDirIndex )
 {
     return baseGroup(project).hasGroup( Config::groupNameBuildDir.arg(buildDirIndex) );
 }
 
 int currentBuildDirIndex( KDevelop::IProject* project )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if ( baseGrp.hasKey( Config::buildDirOverrideIndexKey ) )
         return baseGrp.readEntry<int>( Config::buildDirOverrideIndexKey, 0 );
 
     else
         return baseGrp.readEntry<int>( Config::buildDirIndexKey, 0 ); // default is 0 because QString::number(0) apparently returns an empty string
 }
 
 QString readProjectParameter( KDevelop::IProject* project, const QString& key, const QString& aDefault )
 {
     int buildDirIndex = currentBuildDirIndex(project);
     if (buildDirIndex >= 0)
         return buildDirGroup( project, buildDirIndex ).readEntry( key, aDefault );
 
     else
         return aDefault;
 }
 
 void writeProjectParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     int buildDirIndex = currentBuildDirIndex(project);
     if (buildDirIndex >= 0)
     {
         KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
         buildDirGrp.writeEntry( key, value );
     }
 
     else
     {
-        qWarning() << "cannot write key" << key << "(" << value << ")" << "when no builddir is set!";
+        qCWarning(CMAKE) << "cannot write key" << key << "(" << value << ")" << "when no builddir is set!";
     }
 }
 
 void writeProjectBaseParameter( KDevelop::IProject* project, const QString& key, const QString& value )
 {
     KConfigGroup baseGrp = baseGroup(project);
     baseGrp.writeEntry( key, value );
 }
 
 } // namespace
 
 namespace CMake
 {
 
 KDevelop::Path::List resolveSystemDirs(KDevelop::IProject* project, const QStringList& dirs)
 {
     const KDevelop::Path buildDir(CMake::currentBuildDir(project));
     const KDevelop::Path installDir(CMake::currentInstallDir(project));
 
     KDevelop::Path::List newList;
     newList.reserve(dirs.size());
     foreach(const QString& s, dirs)
     {
         KDevelop::Path dir;
         if(s.startsWith(QLatin1String("#[bin_dir]")))
         {
             dir = KDevelop::Path(buildDir, s);
         }
         else if(s.startsWith(QLatin1String("#[install_dir]")))
         {
             dir = KDevelop::Path(installDir, s);
         }
         else
         {
             dir = KDevelop::Path(s);
         }
 
 //         qCDebug(CMAKE) << "resolved" << s << "to" << d;
 
         if (!newList.contains(dir))
         {
             newList.append(dir);
         }
     }
     return newList;
 }
 
 ///NOTE: when you change this, update @c defaultConfigure in cmakemanagertest.cpp
 bool checkForNeedingConfigure( KDevelop::IProject* project )
 {
     const KDevelop::Path builddir = currentBuildDir(project);
     if( !builddir.isValid() )
     {
         CMakeBuildDirChooser bd;
 
         KDevelop::Path folder = project->path();
         QString relative=CMake::projectRootRelative(project);
         folder.cd(relative);
 
         bd.setSourceFolder( folder );
         bd.setAlreadyUsed( CMake::allBuildDirs(project) );
         bd.setCMakeExecutable(currentCMakeExecutable(project));
 
         if( !bd.exec() )
         {
             return false;
         }
 
         QString newbuilddir = bd.buildFolder().toLocalFile();
         int addedBuildDirIndex = buildDirCount( project ); // old count is the new index
 
         // Initialize the kconfig items with the values from the dialog, this ensures the settings
         // end up in the config file once the changes are saved
         qCDebug(CMAKE) << "adding to cmake config: new builddir index" << addedBuildDirIndex;
         qCDebug(CMAKE) << "adding to cmake config: builddir path " << bd.buildFolder();
         qCDebug(CMAKE) << "adding to cmake config: installdir " << bd.installPrefix();
         qCDebug(CMAKE) << "adding to cmake config: extra args" << bd.extraArguments();
         qCDebug(CMAKE) << "adding to cmake config: build type " << bd.buildType();
         qCDebug(CMAKE) << "adding to cmake config: cmake executable " << bd.cmakeExecutable();
         qCDebug(CMAKE) << "adding to cmake config: environment <null>";
         CMake::setBuildDirCount( project, addedBuildDirIndex + 1 );
         CMake::setCurrentBuildDirIndex( project, addedBuildDirIndex );
         CMake::setCurrentBuildDir( project, bd.buildFolder() );
         CMake::setCurrentInstallDir( project, bd.installPrefix() );
         CMake::setCurrentExtraArguments( project, bd.extraArguments() );
         CMake::setCurrentBuildType( project, bd.buildType() );
         CMake::setCurrentCMakeExecutable(project, bd.cmakeExecutable());
         CMake::setCurrentEnvironment( project, QString() );
 
         return true;
     } else if( !QFile::exists( KDevelop::Path(builddir, QStringLiteral("CMakeCache.txt")).toLocalFile() ) ||
                 //TODO: maybe we could use the builder for that?
                !(QFile::exists( KDevelop::Path(builddir, QStringLiteral("Makefile")).toLocalFile() ) ||
                     QFile::exists( KDevelop::Path(builddir, QStringLiteral("build.ninja")).toLocalFile() ) ) )
     {
         // User entered information already, but cmake hasn't actually been run yet.
         return true;
     }
     return false;
 }
 
 QHash<KDevelop::Path, QStringList> enumerateTargets(const KDevelop::Path& targetsFilePath, const QString& sourceDir, const KDevelop::Path &buildDir)
 {
     const QString buildPath = buildDir.toLocalFile();
     QHash<KDevelop::Path, QStringList> targets;
     QFile targetsFile(targetsFilePath.toLocalFile());
     if (!targetsFile.open(QIODevice::ReadOnly)) {
         qCDebug(CMAKE) << "Couldn't find the Targets file in" << targetsFile.fileName();
     }
 
     QTextStream targetsFileStream(&targetsFile);
     const QRegularExpression rx(QStringLiteral("^(.*)/CMakeFiles/(.*).dir$"));
     while (!targetsFileStream.atEnd()) {
         const QString line = targetsFileStream.readLine();
         auto match = rx.match(line);
         if (!match.isValid())
             qCDebug(CMAKE) << "invalid match for" << line;
         const QString sourcePath = match.captured(1).replace(buildPath, sourceDir);
         targets[KDevelop::Path(sourcePath)].append(match.captured(2));
     }
     return targets;
 }
 
 KDevelop::Path projectRoot(KDevelop::IProject* project)
 {
     if (!project) {
         return {};
     }
 
     return project->path().cd(CMake::projectRootRelative(project));
 }
 
 KDevelop::Path currentBuildDir( KDevelop::IProject* project )
 {
     return KDevelop::Path(readProjectParameter( project, Config::Specific::buildDirPathKey, QString() ));
 }
 
 KDevelop::Path commandsFile(KDevelop::IProject* project)
 {
     auto currentBuildDir = CMake::currentBuildDir(project);
     if (currentBuildDir.isEmpty()) {
         return {};
     }
 
     return KDevelop::Path(currentBuildDir, QStringLiteral("compile_commands.json"));
 }
 
 KDevelop::Path targetDirectoriesFile(KDevelop::IProject* project)
 {
     auto currentBuildDir = CMake::currentBuildDir(project);
     if (currentBuildDir.isEmpty()) {
         return {};
     }
 
     return KDevelop::Path(currentBuildDir, QStringLiteral("CMakeFiles/TargetDirectories.txt"));
 }
 
 QString currentBuildType( KDevelop::IProject* project )
 {
     return readProjectParameter( project, Config::Specific::cmakeBuildTypeKey, QStringLiteral("Release") );
 }
 
 QString findExecutable()
 {
     auto cmake = QStandardPaths::findExecutable(QStringLiteral("cmake"));
 #ifdef Q_OS_WIN
     if (cmake.isEmpty())
         cmake = QStandardPaths::findExecutable("cmake",{
             "C:\\Program Files (x86)\\CMake\\bin",
             "C:\\Program Files\\CMake\\bin",
             "C:\\Program Files (x86)\\CMake 2.8\\bin",
             "C:\\Program Files\\CMake 2.8\\bin"});
 #endif
     return cmake;
 }
 
 KDevelop::Path currentCMakeExecutable(KDevelop::IProject* project)
 {
     const auto systemExecutable = findExecutable();
     auto path = readProjectParameter(project, Config::Specific::cmakeExecutableKey, systemExecutable);
     if (path != systemExecutable) {
         QFileInfo info(path);
         if (!info.isExecutable()) {
             path = systemExecutable;
         }
     }
     return KDevelop::Path(path);
 }
 
 KDevelop::Path currentInstallDir( KDevelop::IProject* project )
 {
     return KDevelop::Path(readProjectParameter( project, Config::Specific::cmakeInstallDirKey, QStringLiteral("/usr/local") ));
 }
 
 QString projectRootRelative( KDevelop::IProject* project )
 {
     return baseGroup(project).readEntry( Config::Old::projectRootRelativeKey, "." );
 }
 
 bool hasProjectRootRelative(KDevelop::IProject* project)
 {
     return baseGroup(project).hasKey( Config::Old::projectRootRelativeKey );
 }
 
 QString currentExtraArguments( KDevelop::IProject* project )
 {
     return readProjectParameter( project, Config::Specific::cmakeArgumentsKey, QString() );
 }
 
 void setCurrentInstallDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeProjectParameter( project, Config::Specific::cmakeInstallDirKey, path.toLocalFile() );
 }
 
 void setCurrentBuildType( KDevelop::IProject* project, const QString& type )
 {
     writeProjectParameter( project, Config::Specific::cmakeBuildTypeKey, type );
 }
 
 void setCurrentCMakeExecutable(KDevelop::IProject* project, const KDevelop::Path& path)
 {
     writeProjectParameter(project, Config::Specific::cmakeExecutableKey, path.toLocalFile());
 }
 
 void setCurrentBuildDir( KDevelop::IProject* project, const KDevelop::Path& path )
 {
     writeProjectParameter( project, Config::Specific::buildDirPathKey, path.toLocalFile() );
 }
 
 void setProjectRootRelative( KDevelop::IProject* project, const QString& relative)
 {
     writeProjectBaseParameter( project, Config::Old::projectRootRelativeKey, relative );
 }
 
 void setCurrentExtraArguments( KDevelop::IProject* project, const QString& string)
 {
     writeProjectParameter( project, Config::Specific::cmakeArgumentsKey, string );
 }
 
 QString currentEnvironment(KDevelop::IProject* project)
 {
     return readProjectParameter( project, Config::Specific::cmakeEnvironmentKey, QString() );
 }
 
 
 int currentBuildDirIndex( KDevelop::IProject* project )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if ( baseGrp.hasKey( Config::buildDirOverrideIndexKey ) )
         return baseGrp.readEntry<int>( Config::buildDirOverrideIndexKey, 0 );
 
     else
         return baseGrp.readEntry<int>( Config::buildDirIndexKey, 0 ); // default is 0 because QString::number(0) apparently returns an empty string
 }
 
 void setCurrentBuildDirIndex( KDevelop::IProject* project, int buildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirIndexKey, QString::number (buildDirIndex) );
 }
 
 void setCurrentEnvironment( KDevelop::IProject* project, const QString& environment )
 {
     writeProjectParameter( project, Config::Specific::cmakeEnvironmentKey, environment );
 }
 
 void initBuildDirConfig( KDevelop::IProject* project )
 {
     int buildDirIndex = currentBuildDirIndex( project );
     if (buildDirCount(project) <= buildDirIndex )
         setBuildDirCount( project, buildDirIndex + 1 );
 }
 
 int buildDirCount( KDevelop::IProject* project )
 {
     return baseGroup(project).readEntry<int>( Config::buildDirCountKey, 0 );
 }
 
 void setBuildDirCount( KDevelop::IProject* project, int count )
 {
     writeProjectBaseParameter( project, Config::buildDirCountKey, QString::number(count) );
 }
 
 void removeBuildDirConfig( KDevelop::IProject* project )
 {
     int buildDirIndex = currentBuildDirIndex( project );
     if ( !buildDirGroupExists( project, buildDirIndex ) )
     {
-        qWarning() << "build directory config" << buildDirIndex << "to be removed but does not exist";
+        qCWarning(CMAKE) << "build directory config" << buildDirIndex << "to be removed but does not exist";
         return;
     }
 
     int bdCount = buildDirCount(project);
     setBuildDirCount( project, bdCount - 1 );
     removeOverrideBuildDirIndex( project );
     setCurrentBuildDirIndex( project, -1 );
 
     // move (rename) the upper config groups to keep the numbering
     // if there's nothing to move, just delete the group physically
     if (buildDirIndex + 1 == bdCount)
         buildDirGroup( project, buildDirIndex ).deleteGroup();
 
     else for (int i = buildDirIndex + 1; i < bdCount; ++i)
     {
         KConfigGroup src = buildDirGroup( project, i );
         KConfigGroup dest = buildDirGroup( project, i - 1 );
         dest.deleteGroup();
         src.copyTo(&dest);
         src.deleteGroup();
     }
 }
 
 QHash<QString, QString> readCacheValues(const KDevelop::Path& cmakeCachePath, QSet<QString> variables)
 {
     QHash<QString, QString> ret;
     QFile file(cmakeCachePath.toLocalFile());
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         qCWarning(CMAKE) << "couldn't open CMakeCache.txt" << cmakeCachePath;
         return ret;
     }
 
     QTextStream in(&file);
     while (!in.atEnd() && !variables.isEmpty())
     {
         QString line = in.readLine().trimmed();
         if(!line.isEmpty() && line[0].isLetter())
         {
             CacheLine c;
             c.readLine(line);
 
             if(!c.isCorrect())
                 continue;
 
             if (variables.remove(c.name())) {
                 ret[c.name()] = c.value();
             }
         }
     }
     return ret;
 }
 
 void updateConfig( KDevelop::IProject* project, int buildDirIndex)
 {
     if (buildDirIndex < 0)
         return;
 
     KConfigGroup buildDirGrp = buildDirGroup( project, buildDirIndex );
     const KDevelop::Path builddir(buildDirGrp.readEntry( Config::Specific::buildDirPathKey, QString() ));
     const KDevelop::Path cacheFilePath( builddir, QStringLiteral("CMakeCache.txt"));
 
     const QMap<QString, QString> keys = {
         { QStringLiteral("CMAKE_COMMAND"), Config::Specific::cmakeExecutableKey },
         { QStringLiteral("CMAKE_INSTALL_PREFIX"), Config::Specific::cmakeInstallDirKey },
         { QStringLiteral("CMAKE_BUILD_TYPE"), Config::Specific::cmakeBuildTypeKey }
     };
 
     const QHash<QString, QString> cacheValues = readCacheValues(cacheFilePath, keys.keys().toSet());
     for(auto it = cacheValues.constBegin(), itEnd = cacheValues.constEnd(); it!=itEnd; ++it) {
         const QString key = keys.value(it.key());
         Q_ASSERT(!key.isEmpty());
         buildDirGrp.writeEntry( key, it.value() );
     }
 }
 
 void attemptMigrate( KDevelop::IProject* project )
 {
     if ( !baseGroup(project).hasKey( Config::Old::projectBuildDirs ) )
     {
         qCDebug(CMAKE) << "CMake settings migration: already done, exiting";
         return;
     }
 
     KConfigGroup baseGrp = baseGroup(project);
 
     KDevelop::Path buildDir( baseGrp.readEntry( Config::Old::currentBuildDirKey, QString() ) );
     int buildDirIndex = -1;
     const QStringList existingBuildDirs = baseGrp.readEntry( Config::Old::projectBuildDirs, QStringList() );
     {
         // also, find current build directory in this list (we need an index, not path)
         QString currentBuildDirCanonicalPath = QDir( buildDir.toLocalFile() ).canonicalPath();
 
         for( int i = 0; i < existingBuildDirs.count(); ++i )
         {
             const QString& nextBuildDir = existingBuildDirs.at(i);
             if( QDir(nextBuildDir).canonicalPath() == currentBuildDirCanonicalPath )
             {
                 buildDirIndex = i;
             }
         }
     }
     int buildDirsCount = existingBuildDirs.count();
 
     qCDebug(CMAKE) << "CMake settings migration: existing build directories" << existingBuildDirs;
     qCDebug(CMAKE) << "CMake settings migration: build directory count" << buildDirsCount;
     qCDebug(CMAKE) << "CMake settings migration: current build directory" << buildDir << "(index" << buildDirIndex << ")";
 
     baseGrp.writeEntry( Config::buildDirCountKey, buildDirsCount );
     baseGrp.writeEntry( Config::buildDirIndexKey, buildDirIndex );
 
     for (int i = 0; i < buildDirsCount; ++i)
     {
         qCDebug(CMAKE) << "CMake settings migration: writing group" << i << ": path" << existingBuildDirs.at(i);
 
         KConfigGroup buildDirGrp = buildDirGroup( project, i );
         buildDirGrp.writeEntry( Config::Specific::buildDirPathKey, existingBuildDirs.at(i) );
     }
 
     baseGrp.deleteEntry( Config::Old::currentBuildDirKey );
     baseGrp.deleteEntry( Config::Old::currentCMakeBinaryKey );
     baseGrp.deleteEntry( Config::Old::currentBuildTypeKey );
     baseGrp.deleteEntry( Config::Old::currentInstallDirKey );
     baseGrp.deleteEntry( Config::Old::currentEnvironmentKey );
     baseGrp.deleteEntry( Config::Old::currentExtraArgumentsKey );
     baseGrp.deleteEntry( Config::Old::projectBuildDirs );
 }
 
 void setOverrideBuildDirIndex( KDevelop::IProject* project, int overrideBuildDirIndex )
 {
     writeProjectBaseParameter( project, Config::buildDirOverrideIndexKey, QString::number(overrideBuildDirIndex) );
 }
 
 void removeOverrideBuildDirIndex( KDevelop::IProject* project, bool writeToMainIndex )
 {
     KConfigGroup baseGrp = baseGroup(project);
 
     if( !baseGrp.hasKey(Config::buildDirOverrideIndexKey) )
         return;
     if( writeToMainIndex )
         baseGrp.writeEntry( Config::buildDirIndexKey, baseGrp.readEntry(Config::buildDirOverrideIndexKey) );
 
     baseGrp.deleteEntry(Config::buildDirOverrideIndexKey);
 }
 
 ICMakeDocumentation* cmakeDocumentation()
 {
     return KDevelop::ICore::self()->pluginController()->extensionForPlugin<ICMakeDocumentation>(QStringLiteral("org.kdevelop.ICMakeDocumentation"));
 }
 
 QStringList allBuildDirs(KDevelop::IProject* project)
 {
     QStringList result;
     int bdCount = buildDirCount(project);
     for (int i = 0; i < bdCount; ++i)
         result += buildDirGroup( project, i ).readEntry( Config::Specific::buildDirPathKey );
     return result;
 }
 
 QString executeProcess(const QString& execName, const QStringList& args)
 {
     Q_ASSERT(!execName.isEmpty());
     qCDebug(CMAKE) << "Executing:" << execName << "::" << args;
 
     QProcess p;
     QTemporaryDir tmp(QStringLiteral("kdevcmakemanager"));
     p.setWorkingDirectory( tmp.path() );
     p.start(execName, args, QIODevice::ReadOnly);
 
     if(!p.waitForFinished())
     {
         qCDebug(CMAKE) << "failed to execute:" << execName;
     }
 
     QByteArray b = p.readAllStandardOutput();
     QString t;
     t.prepend(b.trimmed());
     return t;
 }
 
 QStringList supportedGenerators()
 {
     QStringList generatorNames;
 
     bool hasNinja = ICore::self() && ICore::self()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IProjectBuilder"), QStringLiteral("KDevNinjaBuilder"));
     if (hasNinja)
         generatorNames << QStringLiteral("Ninja");
 
 #ifdef Q_OS_WIN
     // Visual Studio solution is the standard generator under windows, but we don't want to use
     // the VS IDE, so we need nmake makefiles
     generatorNames << "NMake Makefiles";
 #endif
     generatorNames << QStringLiteral("Unix Makefiles");
 
     return generatorNames;
 }
 
 QString defaultGenerator()
 {
     const QStringList generatorNames = supportedGenerators();
 
     QString defGen = generatorNames.value(CMakeBuilderSettings::self()->generator());
     if (defGen.isEmpty())
     {
-        qWarning() << "Couldn't find builder with index " << CMakeBuilderSettings::self()->generator()
+        qCWarning(CMAKE) << "Couldn't find builder with index " << CMakeBuilderSettings::self()->generator()
                    << ", defaulting to 0";
         CMakeBuilderSettings::self()->setGenerator(0);
         defGen = generatorNames.at(0);
     }
     return defGen;
 }
 
 }
 
diff --git a/projectmanagers/qmake/qmakeconfig.cpp b/projectmanagers/qmake/qmakeconfig.cpp
index f981e6575c..0eb296c836 100644
--- a/projectmanagers/qmake/qmakeconfig.cpp
+++ b/projectmanagers/qmake/qmakeconfig.cpp
@@ -1,177 +1,177 @@
 /* KDevelop QMake Support
  *
  * 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 "qmakeconfig.h"
 
 #include <QMutex>
 #include <QDebug>
 #include <QFileInfo>
 #include <QStandardPaths>
 
 #include <KConfigGroup>
 #include <KProcess>
 
 #include <interfaces/iproject.h>
 #include <util/path.h>
 #include "debug.h"
 
 const char QMakeConfig::CONFIG_GROUP[] = "QMake_Builder";
 
 // TODO: migrate to more generic & consistent key term "QMake_Executable"
 const char QMakeConfig::QMAKE_EXECUTABLE[] = "QMake_Binary";
 const char QMakeConfig::BUILD_FOLDER[] = "Build_Folder";
 const char QMakeConfig::INSTALL_PREFIX[] = "Install_Prefix";
 const char QMakeConfig::EXTRA_ARGUMENTS[] = "Extra_Arguments";
 const char QMakeConfig::BUILD_TYPE[] = "Build_Type";
 const char QMakeConfig::ALL_BUILDS[] = "All_Builds";
 
 namespace {
 
 // TODO: Just use QDir::listSeparator once we depend on Qt 5.6
 Q_DECL_CONSTEXPR inline QChar listSeparator() Q_DECL_NOTHROW
 {
 #ifdef Q_OS_WIN
     return QLatin1Char(';');
 #else
     return QLatin1Char(':');
 #endif
 }
 }
 
 using namespace KDevelop;
 
 /// NOTE: KConfig is not thread safe
 QMutex s_buildDirMutex;
 
 bool QMakeConfig::isConfigured(const IProject* project)
 {
     QMutexLocker lock(&s_buildDirMutex);
     KConfigGroup cg(project->projectConfiguration(), CONFIG_GROUP);
     return cg.exists() && cg.hasKey(QMAKE_EXECUTABLE) && cg.hasKey(BUILD_FOLDER);
 }
 
 Path QMakeConfig::buildDirFromSrc(const IProject* project, const Path& srcDir)
 {
     QMutexLocker lock(&s_buildDirMutex);
     KConfigGroup cg(project->projectConfiguration(), QMakeConfig::CONFIG_GROUP);
     Path buildDir = Path(cg.readEntry(QMakeConfig::BUILD_FOLDER, QString()));
     lock.unlock();
 
     if (buildDir.isValid()) {
         buildDir.addPath(project->path().relativePath(srcDir));
     }
     return buildDir;
 }
 
 QString QMakeConfig::qmakeExecutable(const IProject* project)
 {
     QMutexLocker lock(&s_buildDirMutex);
     QString exe;
     if (project) {
         KSharedConfig::Ptr cfg = project->projectConfiguration();
         KConfigGroup group(cfg.data(), CONFIG_GROUP);
         if (group.hasKey(QMAKE_EXECUTABLE)) {
             exe = group.readEntry(QMAKE_EXECUTABLE, QString());
             QFileInfo info(exe);
             if (!info.exists() || !info.isExecutable()) {
-                qWarning() << "bad QMake configured for project " << project->path().toUrl() << ":" << exe;
+                qCWarning(KDEV_QMAKE) << "bad QMake configured for project " << project->path().toUrl() << ":" << exe;
                 exe.clear();
             }
         }
     }
     if (exe.isEmpty()) {
         exe = QStandardPaths::findExecutable(QStringLiteral("qmake"));
     }
     if (exe.isEmpty()) {
         exe = QStandardPaths::findExecutable(QStringLiteral("qmake-qt5"));
     }
     if (exe.isEmpty()) {
         exe = QStandardPaths::findExecutable(QStringLiteral("qmake-qt4"));
     }
     Q_ASSERT(!exe.isEmpty());
     return exe;
 }
 
 QHash<QString, QString> QMakeConfig::queryQMake(const QString& qmakeExecutable, const QStringList& args)
 {
     QHash<QString, QString> hash;
     KProcess p;
     p.setOutputChannelMode(KProcess::OnlyStdoutChannel);
     p << qmakeExecutable << QStringLiteral("-query") << args;
 
     const int rc = p.execute();
     if (rc != 0) {
         qCWarning(KDEV_QMAKE) << "failed to execute qmake query " << p.program().join(QStringLiteral(" ")) << "return code was:" << rc;
         return QHash<QString, QString>();
     }
 
     // TODO: Qt 5.5: Use QTextStream::readLineInto
     QTextStream stream(&p);
     while (!stream.atEnd()) {
         const QString line = stream.readLine();
         const int colon = line.indexOf(':');
         if (colon == -1) {
             continue;
         }
 
         const auto key = line.left(colon);
         const auto value = line.mid(colon + 1);
         hash.insert(key, value);
     }
     qCDebug(KDEV_QMAKE) << "Ran qmake (" << p.program().join(QStringLiteral(" ")) << "), found:" << hash;
     return hash;
 }
 
 QString QMakeConfig::findBasicMkSpec(const QHash<QString, QString>& qmakeVars)
 {
     QStringList paths;
     if (qmakeVars.contains(QStringLiteral("QMAKE_MKSPECS"))) {
         // qt4
         foreach (const QString& dir, qmakeVars["QMAKE_MKSPECS"].split(listSeparator())) {
             paths << dir + "/default/qmake.conf";
         }
     } else if (!qmakeVars.contains(QStringLiteral("QMAKE_MKSPECS")) && qmakeVars.contains(QStringLiteral("QMAKE_SPEC"))) {
         QString path;
         // qt5 doesn't have the MKSPECS nor default anymore
         // let's try to look up the mkspec path ourselves,
         // see QMakeEvaluator::updateMkspecPaths() in QMake source code as reference
         if (qmakeVars.contains(QStringLiteral("QT_HOST_DATA/src"))) {
             // >=qt5.2: since 0d463c05fc4f2e79e5a4e5a5382a1e6ed5d2615e (in Qt5 qtbase repository)
             // mkspecs are no longer copied to the build directory.
             // instead, we have to look them up in the source directory.
             // this commit also introduced the key 'QT_HOST_DATA/src' which we use here
             path = qmakeVars[QStringLiteral("QT_HOST_DATA/src")];
         } else if (qmakeVars.contains(QStringLiteral("QT_HOST_DATA"))) {
             // cross compilation
             path = qmakeVars[QStringLiteral("QT_HOST_DATA")];
         } else {
             Q_ASSERT(qmakeVars.contains("QT_INSTALL_PREFIX"));
             path = qmakeVars[QStringLiteral("QT_INSTALL_PREFIX")];
         }
         path += "/mkspecs/" + qmakeVars[QStringLiteral("QMAKE_SPEC")] + "/qmake.conf";
         paths << path;
     }
 
     foreach (const QString& path, paths) {
         QFileInfo fi(path);
         if (fi.exists())
             return fi.absoluteFilePath();
     }
 
     return QString();
 }
diff --git a/projectmanagers/qmake/qmakemanager.cpp b/projectmanagers/qmake/qmakemanager.cpp
index 2f2ebba3fa..4e75a947c7 100644
--- a/projectmanagers/qmake/qmakemanager.cpp
+++ b/projectmanagers/qmake/qmakemanager.cpp
@@ -1,512 +1,512 @@
 /* KDevelop QMake Support
  *
  * Copyright 2006 Andreas Pakulat <apaku@gmx.de>
  *
  * 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 "qmakemanager.h"
 
 #include <QAction>
 #include <QDebug>
 #include <QDir>
 #include <QIcon>
 #include <QFileInfo>
 #include <QHash>
 #include <QList>
 #include <QUrl>
 
 #include <kio/global.h>
 #include <KConfigGroup>
 #include <KDirWatch>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include <interfaces/icore.h>
 #include <interfaces/iproject.h>
 #include <interfaces/contextmenuextension.h>
 #include <interfaces/context.h>
 #include <interfaces/iruncontroller.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iplugincontroller.h>
 #include <project/projectmodel.h>
 #include <serialization/indexedstring.h>
 
 #include <projectbuilders/qmakebuilder/iqmakebuilder.h>
 
 #include "qmakemodelitems.h"
 #include "qmakeprojectfile.h"
 #include "qmakecache.h"
 #include "qmakemkspecs.h"
 #include "qmakejob.h"
 #include "qmakebuilddirchooserdialog.h"
 #include "qmakeconfig.h"
 #include "qmakeutils.h"
 #include "debug.h"
 
 using namespace KDevelop;
 
 // BEGIN Helpers
 
 QMakeFolderItem* findQMakeFolderParent(ProjectBaseItem* item)
 {
     QMakeFolderItem* p = nullptr;
     while (!p && item) {
         p = dynamic_cast<QMakeFolderItem*>(item);
         item = item->parent();
     }
     return p;
 }
 
 // END Helpers
 
 K_PLUGIN_FACTORY_WITH_JSON(QMakeSupportFactory, "kdevqmakemanager.json", registerPlugin<QMakeProjectManager>();)
 
 QMakeProjectManager* QMakeProjectManager::m_self = nullptr;
 
 QMakeProjectManager* QMakeProjectManager::self()
 {
     return m_self;
 }
 
 QMakeProjectManager::QMakeProjectManager(QObject* parent, const QVariantList&)
     : AbstractFileManagerPlugin(QStringLiteral("kdevqmakemanager"), parent)
     , IBuildSystemManager()
     , m_builder(nullptr)
     , m_runQMake(nullptr)
 {
     Q_ASSERT(!m_self);
     m_self = this;
 
     IPlugin* i = core()->pluginController()->pluginForExtension(QStringLiteral("org.kdevelop.IQMakeBuilder"));
     Q_ASSERT(i);
     m_builder = i->extension<IQMakeBuilder>();
     Q_ASSERT(m_builder);
 
     connect(this, SIGNAL(folderAdded(KDevelop::ProjectFolderItem*)), this,
             SLOT(slotFolderAdded(KDevelop::ProjectFolderItem*)));
 
     m_runQMake = new QAction(QIcon::fromTheme(QStringLiteral("qtlogo")), i18n("Run QMake"), this);
     connect(m_runQMake, &QAction::triggered, this, &QMakeProjectManager::slotRunQMake);
 }
 
 QMakeProjectManager::~QMakeProjectManager()
 {
     m_self = nullptr;
 }
 
 IProjectFileManager::Features QMakeProjectManager::features() const
 {
     return Features(Folders | Targets | Files);
 }
 
 bool QMakeProjectManager::isValid(const Path& path, const bool isFolder, IProject* project) const
 {
     if (!isFolder && path.lastPathSegment().startsWith(QLatin1String("Makefile"))) {
         return false;
     }
     return AbstractFileManagerPlugin::isValid(path, isFolder, project);
 }
 
 Path QMakeProjectManager::buildDirectory(ProjectBaseItem* item) const
 {
     /// TODO: support includes by some other parent or sibling in a different file-tree-branch
     QMakeFolderItem* qmakeItem = findQMakeFolderParent(item);
     Path dir;
     if (qmakeItem) {
         if (!qmakeItem->parent()) {
             // build root item
             dir = QMakeConfig::buildDirFromSrc(qmakeItem->project(), qmakeItem->path());
         } else {
             // build sub-item
             foreach (QMakeProjectFile* pro, qmakeItem->projectFiles()) {
                 if (QDir(pro->absoluteDir()) == QFileInfo(qmakeItem->path().toUrl().toLocalFile() + '/').absoluteDir()
                     || pro->hasSubProject(qmakeItem->path().toUrl().toLocalFile())) {
                     // get path from project root and it to buildDir
                     dir = QMakeConfig::buildDirFromSrc(qmakeItem->project(), Path(pro->absoluteDir()));
                     break;
                 }
             }
         }
     }
 
     qCDebug(KDEV_QMAKE) << "build dir for" << item->text() << item->path() << "is:" << dir;
     return dir;
 }
 
 ProjectFolderItem* QMakeProjectManager::createFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     if (!parent) {
         return projectRootItem(project, path);
     } else if (ProjectFolderItem* buildFolder = buildFolderItem(project, path, parent)) {
         // child folder in a qmake folder
         return buildFolder;
     } else {
         return AbstractFileManagerPlugin::createFolderItem(project, path, parent);
     }
 }
 
 ProjectFolderItem* QMakeProjectManager::projectRootItem(IProject* project, const Path& path)
 {
     QFileInfo fi(path.toLocalFile());
     QDir dir(path.toLocalFile());
 
     auto item = new QMakeFolderItem(project, path);
 
     QHash<QString, QString> qmvars = QMakeUtils::queryQMake(project);
     const QString mkSpecFile = QMakeConfig::findBasicMkSpec(qmvars);
     Q_ASSERT(!mkSpecFile.isEmpty());
     QMakeMkSpecs* mkspecs = new QMakeMkSpecs(mkSpecFile, qmvars);
     mkspecs->setProject(project);
     mkspecs->read();
     QMakeCache* cache = findQMakeCache(project);
     if (cache) {
         cache->setMkSpecs(mkspecs);
         cache->read();
     }
 
     QStringList projectfiles = dir.entryList(QStringList() << QStringLiteral("*.pro"));
     for (const auto& projectfile : projectfiles) {
         Path proPath(path, projectfile);
         /// TODO: use Path in QMakeProjectFile
         QMakeProjectFile* scope = new QMakeProjectFile(proPath.toLocalFile());
         scope->setProject(project);
         scope->setMkSpecs(mkspecs);
         if (cache) {
             scope->setQMakeCache(cache);
         }
         scope->read();
         qCDebug(KDEV_QMAKE) << "top-level scope with variables:" << scope->variables();
         item->addProjectFile(scope);
     }
     return item;
 }
 
 ProjectFolderItem* QMakeProjectManager::buildFolderItem(IProject* project, const Path& path, ProjectBaseItem* parent)
 {
     // find .pro or .pri files in dir
     QDir dir(path.toLocalFile());
     QStringList projectFiles = dir.entryList(QStringList() << QStringLiteral("*.pro")
                                                            << QStringLiteral("*.pri"),
                                              QDir::Files);
     if (projectFiles.isEmpty()) {
         return nullptr;
     }
 
     auto folderItem = new QMakeFolderItem(project, path, parent);
 
     // TODO: included by not-parent file (in a nother file-tree-branch).
     QMakeFolderItem* qmakeParent = findQMakeFolderParent(parent);
     if (!qmakeParent) {
         // happens for bad qmake configurations
         return nullptr;
     }
 
     foreach (const QString& file, projectFiles) {
         const QString absFile = dir.absoluteFilePath(file);
 
         // TODO: multiple includes by different .pro's
         QMakeProjectFile* parentPro = nullptr;
         foreach (QMakeProjectFile* p, qmakeParent->projectFiles()) {
             if (p->hasSubProject(absFile)) {
                 parentPro = p;
                 break;
             }
         }
         if (!parentPro && file.endsWith(QLatin1String(".pri"))) {
             continue;
         }
         qCDebug(KDEV_QMAKE) << "add project file:" << absFile;
         if (parentPro) {
             qCDebug(KDEV_QMAKE) << "parent:" << parentPro->absoluteFile();
         } else {
             qCDebug(KDEV_QMAKE) << "no parent, assume project root";
         }
 
         auto qmscope = new QMakeProjectFile(absFile);
         qmscope->setProject(project);
 
         const QFileInfo info(absFile);
         const QDir d = info.dir();
         /// TODO: cleanup
         if (parentPro) {
             // subdir
             if (QMakeCache* cache = findQMakeCache(project, Path(d.canonicalPath()))) {
                 cache->setMkSpecs(parentPro->mkSpecs());
                 cache->read();
                 qmscope->setQMakeCache(cache);
             } else {
                 qmscope->setQMakeCache(parentPro->qmakeCache());
             }
 
             qmscope->setMkSpecs(parentPro->mkSpecs());
         } else {
             // new project
             QMakeFolderItem* root = dynamic_cast<QMakeFolderItem*>(project->projectItem());
             Q_ASSERT(root);
             qmscope->setMkSpecs(root->projectFiles().first()->mkSpecs());
             if (root->projectFiles().first()->qmakeCache()) {
                 qmscope->setQMakeCache(root->projectFiles().first()->qmakeCache());
             }
         }
 
         if (qmscope->read()) {
             // TODO: only on read?
             folderItem->addProjectFile(qmscope);
         } else {
             delete qmscope;
             return nullptr;
         }
     }
 
     return folderItem;
 }
 
 void QMakeProjectManager::slotFolderAdded(ProjectFolderItem* folder)
 {
     QMakeFolderItem* qmakeParent = dynamic_cast<QMakeFolderItem*>(folder);
     if (!qmakeParent) {
         return;
     }
 
     qCDebug(KDEV_QMAKE) << "adding targets for" << folder->path();
     foreach (QMakeProjectFile* pro, qmakeParent->projectFiles()) {
         foreach (const QString& s, pro->targets()) {
             if (!isValid(Path(folder->path(), s), false, folder->project())) {
                 continue;
             }
             qCDebug(KDEV_QMAKE) << "adding target:" << s;
             Q_ASSERT(!s.isEmpty());
             auto target = new QMakeTargetItem(pro, folder->project(), s, folder);
             foreach (const QString& path, pro->filesForTarget(s)) {
                 new ProjectFileItem(folder->project(), Path(path), target);
                 /// TODO: signal?
             }
         }
     }
 }
 
 ProjectFolderItem* QMakeProjectManager::import(IProject* project)
 {
     const Path dirName = project->path();
     if (dirName.isRemote()) {
         // FIXME turn this into a real warning
         qCWarning(KDEV_QMAKE) << "not a local file. QMake support doesn't handle remote projects";
         return nullptr;
     }
 
     QMakeUtils::checkForNeedingConfigure(project);
 
     ProjectFolderItem* ret = AbstractFileManagerPlugin::import(project);
     connect(projectWatcher(project), &KDirWatch::dirty, this, &QMakeProjectManager::slotDirty);
     return ret;
 }
 
 void QMakeProjectManager::slotDirty(const QString& path)
 {
     if (!path.endsWith(QLatin1String(".pro")) && !path.endsWith(QLatin1String(".pri"))) {
         return;
     }
 
     QFileInfo info(path);
     if (!info.isFile()) {
         return;
     }
 
     const QUrl url = QUrl::fromLocalFile(path);
     if (!isValid(Path(url), false, nullptr)) {
         return;
     }
 
     IProject* project = ICore::self()->projectController()->findProjectForUrl(url);
     if (!project) {
         // this can happen when we create/remove lots of files in a
         // sub dir of a project - ignore such cases for now
         return;
     }
 
     bool finished = false;
     foreach (ProjectFolderItem* folder, project->foldersForPath(IndexedString(KIO::upUrl(url)))) {
         if (QMakeFolderItem* qmakeFolder = dynamic_cast<QMakeFolderItem*>(folder)) {
             foreach (QMakeProjectFile* pro, qmakeFolder->projectFiles()) {
                 if (pro->absoluteFile() == path) {
                     // TODO: children
                     // TODO: cache added
-                    qDebug() << "reloading" << pro << path;
+                    qCDebug(KDEV_QMAKE) << "reloading" << pro << path;
                     pro->read();
                 }
             }
             finished = true;
         } else if (ProjectFolderItem* newFolder = buildFolderItem(project, folder->path(), folder->parent())) {
-            qDebug() << "changing from normal folder to qmake project folder:" << folder->path().toUrl();
+            qCDebug(KDEV_QMAKE) << "changing from normal folder to qmake project folder:" << folder->path().toUrl();
             // .pro / .pri file did not exist before
             while (folder->rowCount()) {
                 newFolder->appendRow(folder->takeRow(0));
             }
             folder->parent()->removeRow(folder->row());
             folder = newFolder;
             finished = true;
         }
         if (finished) {
             // remove existing targets and readd them
             for (int i = 0; i < folder->rowCount(); ++i) {
                 if (folder->child(i)->target()) {
                     folder->removeRow(i);
                 }
             }
             /// TODO: put into it's own function once we add more stuff to that slot
             slotFolderAdded(folder);
             break;
         }
     }
 }
 
 QList<ProjectTargetItem*> QMakeProjectManager::targets(ProjectFolderItem* item) const
 {
     Q_UNUSED(item)
     return QList<ProjectTargetItem*>();
 }
 
 IProjectBuilder* QMakeProjectManager::builder() const
 {
     Q_ASSERT(m_builder);
     return m_builder;
 }
 
 Path::List QMakeProjectManager::collectDirectories(ProjectBaseItem* item, const bool collectIncludes) const
 {
     Path::List list;
     QMakeFolderItem* folder = findQMakeFolderParent(item);
     if (folder) {
         foreach (QMakeProjectFile* pro, folder->projectFiles()) {
             if (pro->files().contains(item->path().toLocalFile())) {
                 const QStringList directories = collectIncludes ? pro->includeDirectories() : pro->frameworkDirectories();
                 foreach (const QString& dir, directories) {
                     Path path(dir);
                     if (!list.contains(path)) {
                         list << path;
                     }
                 }
             }
         }
         if (list.isEmpty()) {
             // fallback for new files, use all possible include dirs
             foreach (QMakeProjectFile* pro, folder->projectFiles()) {
                 const QStringList directories = collectIncludes ? pro->includeDirectories() : pro->frameworkDirectories();
                 foreach (const QString& dir, directories) {
                     Path path(dir);
                     if (!list.contains(path)) {
                         list << path;
                     }
                 }
             }
         }
         // make sure the base dir is included
         if (!list.contains(folder->path())) {
             list << folder->path();
         }
         // qCDebug(KDEV_QMAKE) << "include dirs for" << item->path() << ":" << list;
     }
     return list;
 }
 
 Path::List QMakeProjectManager::includeDirectories(ProjectBaseItem* item) const
 {
     return collectDirectories(item);
 }
 
 Path::List QMakeProjectManager::frameworkDirectories(ProjectBaseItem* item) const
 {
     return collectDirectories(item, false);
 }
 
 QHash<QString, QString> QMakeProjectManager::defines(ProjectBaseItem* item) const
 {
     QHash<QString, QString> d;
     QMakeFolderItem* folder = findQMakeFolderParent(item);
     if (!folder) {
         // happens for bad qmake configurations
         return d;
     }
     foreach (QMakeProjectFile* pro, folder->projectFiles()) {
         foreach (QMakeProjectFile::DefinePair def, pro->defines()) {
             d.insert(def.first, def.second);
         }
     }
     return d;
 }
 
 bool QMakeProjectManager::hasBuildInfo(KDevelop::ProjectBaseItem* item) const
 {
     return findQMakeFolderParent(item);
 }
 
 QMakeCache* QMakeProjectManager::findQMakeCache(IProject* project, const Path& path) const
 {
     QDir curdir(QMakeConfig::buildDirFromSrc(project, !path.isValid() ? project->path() : path).toLocalFile());
     curdir.makeAbsolute();
     while (!curdir.exists(QStringLiteral(".qmake.cache")) && !curdir.isRoot() && curdir.cdUp()) {
-        qDebug() << curdir;
+        qCDebug(KDEV_QMAKE) << curdir;
     }
 
     if (curdir.exists(QStringLiteral(".qmake.cache"))) {
-        qDebug() << "Found QMake cache in " << curdir.absolutePath();
+        qCDebug(KDEV_QMAKE) << "Found QMake cache in " << curdir.absolutePath();
         return new QMakeCache(curdir.canonicalPath() + "/.qmake.cache");
     }
     return nullptr;
 }
 
 ContextMenuExtension QMakeProjectManager::contextMenuExtension(Context* context)
 {
     ContextMenuExtension ext;
 
     if (context->hasType(Context::ProjectItemContext)) {
         ProjectItemContext* pic = dynamic_cast<ProjectItemContext*>(context);
         Q_ASSERT(pic);
         if (pic->items().isEmpty()) {
             return ext;
         }
 
         m_actionItem = dynamic_cast<QMakeFolderItem*>(pic->items().first());
         if (m_actionItem) {
             ext.addAction(ContextMenuExtension::ProjectGroup, m_runQMake);
         }
     }
 
     return ext;
 }
 
 void QMakeProjectManager::slotRunQMake()
 {
     Q_ASSERT(m_actionItem);
 
     Path srcDir = m_actionItem->path();
     Path buildDir = QMakeConfig::buildDirFromSrc(m_actionItem->project(), srcDir);
     QMakeJob* job = new QMakeJob(srcDir.toLocalFile(), buildDir.toLocalFile(), this);
 
     job->setQMakePath(QMakeConfig::qmakeExecutable(m_actionItem->project()));
 
     KConfigGroup cg(m_actionItem->project()->projectConfiguration(), QMakeConfig::CONFIG_GROUP);
     QString installPrefix = cg.readEntry(QMakeConfig::INSTALL_PREFIX, QString());
     if (!installPrefix.isEmpty())
         job->setInstallPrefix(installPrefix);
     job->setBuildType(cg.readEntry<int>(QMakeConfig::BUILD_TYPE, 0));
     job->setExtraArguments(cg.readEntry(QMakeConfig::EXTRA_ARGUMENTS, QString()));
 
     KDevelop::ICore::self()->runController()->registerJob(job);
 }
 
 #include "qmakemanager.moc"
diff --git a/providers/ghprovider/ghresource.cpp b/providers/ghprovider/ghresource.cpp
index c0f786aa17..275af87c09 100644
--- a/providers/ghprovider/ghresource.cpp
+++ b/providers/ghprovider/ghresource.cpp
@@ -1,205 +1,205 @@
 /* This file is part of KDevelop
  *
  * Copyright (C) 2012-2013 Miquel Sabaté <mikisabate@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 <QUrl>
 #include <kio/scheduler.h>
 #include <kio/transferjob.h>
 #include <kio/storedtransferjob.h>
 #include <QJsonDocument>
 #include <QDebug>
 #include <QHostInfo>
 #include <QDateTime>
 
 #include "debug.h"
 #include <ghresource.h>
 #include <ghprovidermodel.h>
 
 
 namespace gh
 {
 /// Base url for the Github API v3.
 const static QUrl baseUrl(QStringLiteral("https://api.github.com"));
 
 Resource::Resource(QObject *parent, ProviderModel *model)
     : QObject(parent), m_model(model)
 {
     /* There's nothing to do here */
 }
 
 void Resource::searchRepos(const QString &uri, const QString &token)
 {
     KIO::TransferJob *job = getTransferJob(uri, token);
     connect(job, &KIO::TransferJob::data,
             this, &Resource::slotRepos);
 }
 
 void Resource::getOrgs(const QString &token)
 {
     KIO::TransferJob *job = getTransferJob(QStringLiteral("/user/orgs"), token);
     connect(job, &KIO::TransferJob::data,
             this, &Resource::slotOrgs);
 }
 
 void Resource::authenticate(const QString &name, const QString &password)
 {
     QUrl url = baseUrl;
     url = url.adjusted(QUrl::StripTrailingSlash);
     url.setPath(url.path() + '/' + "/authorizations");
 
     // generate a unique token, see bug 372144
     const QString tokenName = "KDevelop Github Provider : "
         + QHostInfo::localHostName() + " - "
         + QDateTime::currentDateTimeUtc().toString();
     const QByteArray data = "{ \"scopes\": [\"repo\"], \"note\": \"" + tokenName.toUtf8() + "\" }";
 
     KIO::StoredTransferJob *job = KIO::storedHttpPost(data, url, KIO::HideProgressInfo);
     job->setProperty("requestedTokenName", tokenName);
     job->addMetaData(QStringLiteral("customHTTPHeader"), "Authorization: Basic " + QString (name + ':' + password).toUtf8().toBase64());
     connect(job, &KIO::StoredTransferJob::result, this, &Resource::slotAuthenticate);
     job->start();
 }
 
 void Resource::revokeAccess(const QString &id, const QString &name, const QString &password)
 {
     QUrl url = baseUrl;
     url.setPath(url.path() + "/authorizations/" + id);
     KIO::TransferJob *job = KIO::http_delete(url, KIO::HideProgressInfo);
     job->addMetaData(QStringLiteral("customHTTPHeader"), "Authorization: Basic " + QString (name + ':' + password).toUtf8().toBase64());
     /* And we don't care if it's successful ;) */
     job->start();
 }
 
 KIO::TransferJob * Resource::getTransferJob(const QString &uri, const QString &token) const
 {
     QUrl url = baseUrl;
     url = url.adjusted(QUrl::StripTrailingSlash);
     url.setPath(url.path() + '/' + uri);
     KIO::TransferJob *job = KIO::get(url, KIO::Reload, KIO::HideProgressInfo);
     if (!token.isEmpty())
         job->addMetaData(QStringLiteral("customHTTPHeader"), "Authorization: token " + token);
     return job;
 }
 
 void Resource::retrieveRepos(const QByteArray &data)
 {
     QJsonParseError error;
     QJsonDocument doc = QJsonDocument::fromJson(data, &error);
 
     if (error.error == 0) {
         QVariantList map = doc.toVariant().toList();
         m_model->clear();
         foreach (const QVariant &it, map) {
             const QVariantMap &map = it.toMap();
             Response res;
             res.name = map.value(QStringLiteral("name")).toString();
             res.url = map.value(QStringLiteral("clone_url")).toUrl();
             if (map.value(QStringLiteral("fork")).toBool())
                 res.kind = Fork;
             else if (map.value(QStringLiteral("private")).toBool())
                 res.kind = Private;
             else
                 res.kind = Public;
             ProviderItem *item = new ProviderItem(res);
             m_model->appendRow(item);
         }
     }
     emit reposUpdated();
 }
 
 void Resource::retrieveOrgs(const QByteArray &data)
 {
     QStringList res;
     QJsonParseError error;
     QJsonDocument doc = QJsonDocument::fromJson(data, &error);
 
     if (error.error == 0) {
         QVariantList json = doc.toVariant().toList();
         foreach (QVariant it, json) {
             QVariantMap map = it.toMap();
             res << map.value(QStringLiteral("login")).toString();
         }
     }
     emit orgsUpdated(res);
 }
 
 void Resource::slotAuthenticate(KJob *job)
 {
     const QString tokenName = job->property("requestedTokenName").toString();
     Q_ASSERT(!tokenName.isEmpty());
 
     if (job->error()) {
         emit authenticated("", "", tokenName);
         return;
     }
 
     QJsonParseError error;
     QJsonDocument doc = QJsonDocument::fromJson(qobject_cast<KIO::StoredTransferJob *>(job)->data(), &error);
 
     qCDebug(GHPROVIDER) << "Response:" << doc;
 
     if (error.error == 0) {
         QVariantMap map = doc.toVariant().toMap();
         emit authenticated(map.value(QStringLiteral("id")).toByteArray(),
                            map.value(QStringLiteral("token")).toByteArray(), tokenName);
     } else
         emit authenticated("", "", tokenName);
 }
 
 void Resource::slotRepos(KIO::Job *job, const QByteArray &data)
 {
     if (!job) {
-        qWarning() << "NULL job returned!";
+        qCWarning(GHPROVIDER) << "NULL job returned!";
         return;
     }
     if (job->error()) {
-        qWarning() << "Job error: " << job->errorString();
+        qCWarning(GHPROVIDER) << "Job error: " << job->errorString();
         return;
     }
 
     m_temp.append(data);
     if (data.isEmpty()) {
         retrieveRepos(m_temp);
         m_temp = "";
     }
 }
 
 void Resource::slotOrgs(KIO::Job *job, const QByteArray &data)
 {
     QList<QString> res;
 
     if (!job) {
-        qWarning() << "NULL job returned!";
+        qCWarning(GHPROVIDER) << "NULL job returned!";
         emit orgsUpdated(res);
         return;
     }
     if (job->error()) {
-        qWarning() << "Job error: " << job->errorString();
+        qCWarning(GHPROVIDER) << "Job error: " << job->errorString();
         emit orgsUpdated(res);
         return;
     }
 
     m_orgTemp.append(data);
     if (data.isEmpty()) {
         retrieveOrgs(m_orgTemp);
         m_orgTemp = "";
     }
 }
 
 } // End of namespace gh