Debugger: Remove unneeded qualifications

Mostly done using the following ruby script:
Dir.glob('**/*.cpp').each { |file|
  next if file =~ %r{src/shared/qbs|/qmljs/}
  s = File.read(file)
  s.scan(/^using namespace (.*);$/) {
    ns = $1
    t = s.gsub(/^(.*)\b#{ns}::((?!Const)[A-Z])/) { |m|
      before = $1
      char = $2
      if before =~ /"|\/\/|\\|using|SIGNAL|SLOT|Q_/
        m
      else
        before + char
      end
    }
    if t != s
      puts file
      File.open(file, 'w').write(t)
    end
  }
}

Change-Id: I1aa1a2b6ccbafeb1a8f3053fffa39b3f96992591
Reviewed-by: hjk <hjk@theqtcompany.com>

src/plugins/debugger/breakhandler.cpp

@@ -293,7 +293,7 @@ QIcon BreakHandler::emptyIcon()
 
 static inline bool fileNameMatch(const QString &f1, const QString &f2)
 {
-    if (Utils::HostOsInfo::fileNameCaseSensitivity() == Qt::CaseInsensitive)
+    if (HostOsInfo::fileNameCaseSensitivity() == Qt::CaseInsensitive)
         return f1.compare(f2, Qt::CaseInsensitive) == 0;
     return f1 == f2;
 }
@@ -637,7 +637,7 @@ QVariant BreakpointItem::data(int column, int role) const
                 if (str.isEmpty() && !m_params.fileName.isEmpty())
                     str = m_params.fileName;
                 if (str.isEmpty()) {
-                    QString s = Utils::FileName::fromString(str).fileName();
+                    QString s = FileName::fromString(str).fileName();
                     if (!s.isEmpty())
                         str = s;
                 }

src/plugins/debugger/cdb/cdbengine.cpp

@@ -2980,7 +2980,7 @@ CdbEngine::NormalizedSourceFileName CdbEngine::sourceMapNormalizeFileNameFromDeb
     const QString fileName = cdbSourcePathMapping(QDir::toNativeSeparators(f), m_sourcePathMappings,
                                                   DebuggerToSource);
     // Up/lower case normalization according to Windows.
-    const QString normalized = Utils::FileUtils::normalizePathName(fileName);
+    const QString normalized = FileUtils::normalizePathName(fileName);
     if (debugSourceMapping)
         qDebug(" sourceMapNormalizeFileNameFromDebugger %s->%s", qPrintable(fileName), qPrintable(normalized));
     // Check if it really exists, that is normalize worked and QFileInfo confirms it.

src/plugins/debugger/debuggerdialogs.cpp

@@ -105,19 +105,19 @@ namespace Internal {
 ///////////////////////////////////////////////////////////////////////
 
 DebuggerKitChooser::DebuggerKitChooser(Mode mode, QWidget *parent)
-    : ProjectExplorer::KitChooser(parent)
-    , m_hostAbi(ProjectExplorer::Abi::hostAbi())
+    : KitChooser(parent)
+    , m_hostAbi(Abi::hostAbi())
     , m_mode(mode)
 {
 }
 
 // Match valid debuggers and restrict local debugging to compatible toolchains.
-bool DebuggerKitChooser::kitMatches(const ProjectExplorer::Kit *k) const
+bool DebuggerKitChooser::kitMatches(const Kit *k) const
 {
     if (!DebuggerKitInformation::isValidDebugger(k))
         return false;
     if (m_mode == LocalDebugging) {
-        const ProjectExplorer::ToolChain *tc = ToolChainKitInformation::toolChain(k);
+        const ToolChain *tc = ToolChainKitInformation::toolChain(k);
         return tc && tc->targetAbi().os() == m_hostAbi.os();
     }
     return true;

src/plugins/debugger/debuggerengine.cpp

@@ -313,7 +313,7 @@ public:
 
     DisassemblerAgent m_disassemblerAgent;
     MemoryAgent m_memoryAgent;
-    QScopedPointer<TextEditor::TextMark> m_locationMark;
+    QScopedPointer<TextMark> m_locationMark;
     QTimer m_locationTimer;
 
     bool m_isStateDebugging;
@@ -594,9 +594,9 @@ void DebuggerEngine::gotoLocation(const Location &loc)
         editor->document()->setProperty(Constants::OPENED_BY_DEBUGGER, true);
 
     if (loc.needsMarker()) {
-        d->m_locationMark.reset(new TextEditor::TextMark(file, line));
+        d->m_locationMark.reset(new TextMark(file, line));
         d->m_locationMark->setIcon(Internal::locationMarkIcon());
-        d->m_locationMark->setPriority(TextEditor::TextMark::HighPriority);
+        d->m_locationMark->setPriority(TextMark::HighPriority);
     }
 
     //qDebug() << "MEMORY: " << d->m_memoryAgent.hasVisibleEditor();
@@ -1404,7 +1404,7 @@ Terminal *DebuggerEngine::terminal() const
     return &d->m_terminal;
 }
 
-bool DebuggerEngine::setToolTipExpression(TextEditor::TextEditorWidget *,
+bool DebuggerEngine::setToolTipExpression(TextEditorWidget *,
     const DebuggerToolTipContext &)
 {
     return false;
@@ -1714,7 +1714,7 @@ void DebuggerEngine::showStoppedBySignalMessageBox(QString meaning, QString name
                            "<table><tr><td>Signal name : </td><td>%1</td></tr>"
                            "<tr><td>Signal meaning : </td><td>%2</td></tr></table>")
             .arg(name, meaning);
-    Core::AsynchronousMessageBox::information(tr("Signal received"), msg);
+    AsynchronousMessageBox::information(tr("Signal received"), msg);
 }
 
 void DebuggerEngine::showStoppedByExceptionMessageBox(const QString &description)
@@ -1722,7 +1722,7 @@ void DebuggerEngine::showStoppedByExceptionMessageBox(const QString &description
     const QString msg =
         tr("<p>The inferior stopped because it triggered an exception.<p>%1").
                          arg(description);
-    Core::AsynchronousMessageBox::information(tr("Exception Triggered"), msg);
+    AsynchronousMessageBox::information(tr("Exception Triggered"), msg);
 }
 
 void DebuggerEngine::openMemoryView(const MemoryViewSetupData &data)
@@ -1762,7 +1762,7 @@ void DebuggerEngine::validateExecutable(DebuggerStartParameters *sp)
     const bool warnOnRelease = boolSetting(WarnOnReleaseBuilds);
     QString detailedWarning;
     switch (sp->toolChainAbi.binaryFormat()) {
-    case ProjectExplorer::Abi::PEFormat: {
+    case Abi::PEFormat: {
         if (!warnOnRelease || (sp->masterEngineType != CdbEngineType))
             return;
         if (!binary.endsWith(QLatin1String(".exe"), Qt::CaseInsensitive))
@@ -1777,7 +1777,7 @@ void DebuggerEngine::validateExecutable(DebuggerStartParameters *sp)
         }
         break;
     }
-    case ProjectExplorer::Abi::ElfFormat: {
+    case Abi::ElfFormat: {
 
         Utils::ElfReader reader(binary);
         Utils::ElfData elfData = reader.readHeaders();
@@ -1876,7 +1876,7 @@ void DebuggerEngine::validateExecutable(DebuggerStartParameters *sp)
         return;
     }
     if (warnOnRelease) {
-        Core::AsynchronousMessageBox::information(tr("Warning"),
+        AsynchronousMessageBox::information(tr("Warning"),
                        tr("This does not seem to be a \"Debug\" build.\n"
                           "Setting breakpoints by file name and line number may fail.")
                        + QLatin1Char('\n') + detailedWarning);

src/plugins/debugger/debuggeritem.cpp

@@ -232,7 +232,7 @@ void DebuggerItem::setEngineType(const DebuggerEngineType &engineType)
     m_engineType = engineType;
 }
 
-void DebuggerItem::setCommand(const Utils::FileName &command)
+void DebuggerItem::setCommand(const FileName &command)
 {
     m_command = command;
 }
@@ -257,7 +257,7 @@ void DebuggerItem::setAutoDetectionSource(const QString &autoDetectionSource)
     m_autoDetectionSource = autoDetectionSource;
 }
 
-void DebuggerItem::setAbis(const QList<ProjectExplorer::Abi> &abis)
+void DebuggerItem::setAbis(const QList<Abi> &abis)
 {
     m_abis = abis;
 }

src/plugins/debugger/debuggerkitinformation.cpp

@@ -336,14 +336,14 @@ KitInformation::ItemList DebuggerKitInformation::toUserOutput(const Kit *k) cons
     return ItemList() << qMakePair(tr("Debugger"), displayString(k));
 }
 
-FileName DebuggerKitInformation::debuggerCommand(const ProjectExplorer::Kit *k)
+FileName DebuggerKitInformation::debuggerCommand(const Kit *k)
 {
     const DebuggerItem *item = debugger(k);
     QTC_ASSERT(item, return FileName());
     return item->command();
 }
 
-DebuggerEngineType DebuggerKitInformation::engineType(const ProjectExplorer::Kit *k)
+DebuggerEngineType DebuggerKitInformation::engineType(const Kit *k)
 {
     const DebuggerItem *item = debugger(k);
     QTC_ASSERT(item, return NoEngineType);

src/plugins/debugger/debuggermainwindow.cpp

@@ -89,16 +89,16 @@ public:
     bool isQmlActive() const;
     void setSimpleDockWidgetArrangement();
     // Debuggable languages are registered with this function.
-    void addLanguage(DebuggerLanguage language, const Core::Context &context);
+    void addLanguage(DebuggerLanguage language, const Context &context);
 
     QDockWidget *dockWidget(const QString &objectName) const
         { return q->findChild<QDockWidget *>(objectName); }
 
 public slots:
     void resetDebuggerLayout();
-    void updateUiForProject(ProjectExplorer::Project *project);
-    void updateUiForTarget(ProjectExplorer::Target *target);
-    void updateUiForRunConfiguration(ProjectExplorer::RunConfiguration *rc);
+    void updateUiForProject(Project *project);
+    void updateUiForTarget(Target *target);
+    void updateUiForRunConfiguration(RunConfiguration *rc);
     void updateUiForCurrentRunConfiguration();
     void updateActiveLanguages();
     void updateDockWidgetSettings();
@@ -162,26 +162,24 @@ DebuggerMainWindowPrivate::DebuggerMainWindowPrivate(DebuggerMainWindow *mw)
 void DebuggerMainWindowPrivate::updateUiForProject(Project *project)
 {
     if (m_previousProject) {
-        disconnect(m_previousProject,
-            SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
-            this, SLOT(updateUiForTarget(ProjectExplorer::Target*)));
+        disconnect(m_previousProject, &Project::activeTargetChanged,
+            this, &DebuggerMainWindowPrivate::updateUiForTarget);
     }
     m_previousProject = project;
     if (!project) {
         updateUiForTarget(0);
         return;
     }
-    connect(project, SIGNAL(activeTargetChanged(ProjectExplorer::Target*)),
-        SLOT(updateUiForTarget(ProjectExplorer::Target*)));
+    connect(project, &Project::activeTargetChanged,
+            this, &DebuggerMainWindowPrivate::updateUiForTarget);
     updateUiForTarget(project->activeTarget());
 }
 
 void DebuggerMainWindowPrivate::updateUiForTarget(Target *target)
 {
     if (m_previousTarget) {
-         disconnect(m_previousTarget,
-            SIGNAL(activeRunConfigurationChanged(ProjectExplorer::RunConfiguration*)),
-            this, SLOT(updateUiForRunConfiguration(ProjectExplorer::RunConfiguration*)));
+         disconnect(m_previousTarget, &Target::activeRunConfigurationChanged,
+                    this, &DebuggerMainWindowPrivate::updateUiForRunConfiguration);
     }
 
     m_previousTarget = target;
@@ -191,9 +189,8 @@ void DebuggerMainWindowPrivate::updateUiForTarget(Target *target)
         return;
     }
 
-    connect(target,
-        SIGNAL(activeRunConfigurationChanged(ProjectExplorer::RunConfiguration*)),
-        SLOT(updateUiForRunConfiguration(ProjectExplorer::RunConfiguration*)));
+    connect(target, &Target::activeRunConfigurationChanged,
+            this, &DebuggerMainWindowPrivate::updateUiForRunConfiguration);
     updateUiForRunConfiguration(target->activeRunConfiguration());
 }
 
@@ -297,7 +294,7 @@ void DebuggerMainWindow::onModeChanged(IMode *mode)
 void DebuggerMainWindowPrivate::createViewsMenuItems()
 {
     Context debugcontext(Constants::C_DEBUGMODE);
-    m_viewsMenu = Core::ActionManager::actionContainer(Id(Core::Constants::M_WINDOW_VIEWS));
+    m_viewsMenu = ActionManager::actionContainer(Id(Core::Constants::M_WINDOW_VIEWS));
     QTC_ASSERT(m_viewsMenu, return);
 
     QAction *openMemoryEditorAction = new QAction(this);
@@ -307,20 +304,20 @@ void DebuggerMainWindowPrivate::createViewsMenuItems()
 
     // Add menu items
     Command *cmd = 0;
-    cmd = Core::ActionManager::registerAction(openMemoryEditorAction,
+    cmd = ActionManager::registerAction(openMemoryEditorAction,
         "Debugger.Views.OpenMemoryEditor", debugcontext);
     cmd->setAttribute(Command::CA_Hide);
     m_viewsMenu->addAction(cmd, Core::Constants::G_DEFAULT_THREE);
 
-    cmd = Core::ActionManager::registerAction(q->menuSeparator1(),
+    cmd = ActionManager::registerAction(q->menuSeparator1(),
         "Debugger.Views.Separator1", debugcontext);
     cmd->setAttribute(Command::CA_Hide);
     m_viewsMenu->addAction(cmd, Core::Constants::G_DEFAULT_THREE);
-    cmd = Core::ActionManager::registerAction(q->autoHideTitleBarsAction(),
+    cmd = ActionManager::registerAction(q->autoHideTitleBarsAction(),
         "Debugger.Views.AutoHideTitleBars", debugcontext);
     cmd->setAttribute(Command::CA_Hide);
     m_viewsMenu->addAction(cmd, Core::Constants::G_DEFAULT_THREE);
-    cmd = Core::ActionManager::registerAction(q->menuSeparator2(),
+    cmd = ActionManager::registerAction(q->menuSeparator2(),
         "Debugger.Views.Separator2", debugcontext);
     cmd->setAttribute(Command::CA_Hide);
     m_viewsMenu->addAction(cmd, Core::Constants::G_DEFAULT_THREE);
@@ -406,8 +403,8 @@ QDockWidget *DebuggerMainWindow::createDockWidget(const DebuggerLanguage &langua
     Context globalContext(Core::Constants::C_GLOBAL);
 
     QAction *toggleViewAction = dockWidget->toggleViewAction();
-    Command *cmd = Core::ActionManager::registerAction(toggleViewAction,
-             Core::Id("Debugger.").withSuffix(widget->objectName()), globalContext);
+    Command *cmd = ActionManager::registerAction(toggleViewAction,
+             Id("Debugger.").withSuffix(widget->objectName()), globalContext);
     cmd->setAttribute(Command::CA_Hide);
 
     dockWidget->installEventFilter(&d->m_resizeEventFilter);
@@ -429,10 +426,10 @@ void DebuggerMainWindow::addStagedMenuEntries()
 
 QWidget *DebuggerMainWindow::createContents(IMode *mode)
 {
-    connect(SessionManager::instance(), SIGNAL(startupProjectChanged(ProjectExplorer::Project*)),
-        d, SLOT(updateUiForProject(ProjectExplorer::Project*)));
+    connect(SessionManager::instance(), &SessionManager::startupProjectChanged,
+        d, &DebuggerMainWindowPrivate::updateUiForProject);
 
-    d->m_viewsMenu = Core::ActionManager::actionContainer(Core::Id(Core::Constants::M_WINDOW_VIEWS));
+    d->m_viewsMenu = ActionManager::actionContainer(Id(Core::Constants::M_WINDOW_VIEWS));
     QTC_ASSERT(d->m_viewsMenu, return 0);
 
     //d->m_mainWindow = new Internal::DebuggerMainWindow(this);

src/plugins/debugger/debuggeroptionspage.cpp

@@ -92,7 +92,7 @@ public:
 // DebuggerItemModel
 // --------------------------------------------------------------------------
 
-class DebuggerItemModel : public Utils::TreeModel
+class DebuggerItemModel : public TreeModel
 {
     Q_DECLARE_TR_FUNCTIONS(Debugger::DebuggerOptionsPage)
 

src/plugins/debugger/debuggerplugin.cpp

@@ -418,12 +418,12 @@ static QToolButton *toolButton(QAction *action)
     return button;
 }
 
-static void setProxyAction(ProxyAction *proxy, Core::Id id)
+static void setProxyAction(ProxyAction *proxy, Id id)
 {
     proxy->setAction(ActionManager::command(id)->action());
 }
 
-static QToolButton *toolButton(Core::Id id)
+static QToolButton *toolButton(Id id)
 {
     return toolButton(ActionManager::command(id)->action());
 }
@@ -688,12 +688,12 @@ public:
         }
     }
 
-    void editorOpened(Core::IEditor *editor);
-    void updateBreakMenuItem(Core::IEditor *editor);
+    void editorOpened(IEditor *editor);
+    void updateBreakMenuItem(IEditor *editor);
     void setBusyCursor(bool busy);
-    void requestMark(TextEditor::TextEditorWidget *widget, int lineNumber,
-                     TextEditor::TextMarkRequestKind kind);
-    void requestContextMenu(TextEditor::TextEditorWidget *widget,
+    void requestMark(TextEditorWidget *widget, int lineNumber,
+                     TextMarkRequestKind kind);
+    void requestContextMenu(TextEditorWidget *widget,
                             int lineNumber, QMenu *menu);
 
     void activatePreviousMode();
@@ -703,7 +703,7 @@ public:
                                        const QString &tracePointMessage = QString());
     void toggleBreakpointByAddress(quint64 address,
                                    const QString &tracePointMessage = QString());
-    void onModeChanged(Core::IMode *mode);
+    void onModeChanged(IMode *mode);
     void onCoreAboutToOpen();
     void showSettingsDialog();
     void updateDebugWithoutDeployMenu();
@@ -745,11 +745,11 @@ public:
     void cleanupViews();
     void setInitialState();
 
-    void fontSettingsChanged(const TextEditor::FontSettings &settings);
+    void fontSettingsChanged(const FontSettings &settings);
 
     void updateState(DebuggerEngine *engine);
     void updateWatchersWindow(bool showWatch, bool showReturn);
-    void onCurrentProjectChanged(ProjectExplorer::Project *project);
+    void onCurrentProjectChanged(Project *project);
 
     void sessionLoaded();
     void aboutToUnloadSession();
@@ -760,7 +760,7 @@ public:
 #ifdef WITH_TESTS
 public slots:
     void testLoadProject(const QString &proFile, const TestCallBack &cb);
-    void testProjectLoaded(ProjectExplorer::Project *project);
+    void testProjectLoaded(Project *project);
     void testProjectEvaluated();
     void testProjectBuilt(bool success);
     void testUnloadProject();
@@ -1276,9 +1276,9 @@ bool DebuggerPluginPrivate::initialize(const QStringList &arguments,
     // Cpp/Qml ui setup
     m_mainWindow = new DebuggerMainWindow;
 
-    TaskHub::addCategory(Debugger::Constants::TASK_CATEGORY_DEBUGGER_DEBUGINFO,
+    TaskHub::addCategory(TASK_CATEGORY_DEBUGGER_DEBUGINFO,
                          tr("Debug Information"));
-    TaskHub::addCategory(Debugger::Constants::TASK_CATEGORY_DEBUGGER_RUNTIME,
+    TaskHub::addCategory(TASK_CATEGORY_DEBUGGER_RUNTIME,
                          tr("Debugger Runtime"));
 
     return true;
@@ -1330,7 +1330,7 @@ void DebuggerPluginPrivate::onCurrentProjectChanged(Project *project)
     m_startAction->setEnabled(canRun);
     m_startAction->setToolTip(whyNot);
     m_debugWithoutDeployAction->setEnabled(canRun);
-    setProxyAction(m_visibleStartAction, Core::Id(Constants::DEBUG));
+    setProxyAction(m_visibleStartAction, Id(Constants::DEBUG));
 }
 
 void DebuggerPluginPrivate::debugProject()
@@ -1441,7 +1441,7 @@ void DebuggerPluginPrivate::attachToProcess(bool startServerOnly)
         DebuggerKitChooser::RemoteDebugging : DebuggerKitChooser::LocalDebugging;
     DebuggerKitChooser *kitChooser = new DebuggerKitChooser(mode);
     DeviceProcessesDialog *dlg = new DeviceProcessesDialog(kitChooser, ICore::dialogParent());
-    dlg->addAcceptButton(ProjectExplorer::DeviceProcessesDialog::tr("&Attach to Process"));
+    dlg->addAcceptButton(DeviceProcessesDialog::tr("&Attach to Process"));
     dlg->showAllDevices();
     if (dlg->exec() == QDialog::Rejected) {
         delete dlg;
@@ -1508,7 +1508,7 @@ DebuggerRunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
     IDevice::ConstPtr device = DeviceKitInformation::device(kit);
     QTC_ASSERT(device, return 0);
     if (process.pid == 0) {
-        Core::AsynchronousMessageBox::warning(tr("Warning"),
+        AsynchronousMessageBox::warning(tr("Warning"),
                                               tr("Cannot attach to process with PID 0"));
         return 0;
     }
@@ -1517,14 +1517,14 @@ DebuggerRunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
     if (const ToolChain *tc = ToolChainKitInformation::toolChain(kit))
         isWindows = tc->targetAbi().os() == Abi::WindowsOS;
     if (isWindows && isWinProcessBeingDebugged(process.pid)) {
-        Core::AsynchronousMessageBox::warning(tr("Process Already Under Debugger Control"),
+        AsynchronousMessageBox::warning(tr("Process Already Under Debugger Control"),
                              tr("The process %1 is already under the control of a debugger.\n"
                                 "Qt Creator cannot attach to it.").arg(process.pid));
         return 0;
     }
 
     if (device->type() != PE::DESKTOP_DEVICE_TYPE) {
-        Core::AsynchronousMessageBox::warning(tr("Not a Desktop Device Type"),
+        AsynchronousMessageBox::warning(tr("Not a Desktop Device Type"),
                              tr("It is only possible to attach to a locally running process."));
         return 0;
     }
@@ -1865,7 +1865,7 @@ static void changeFontSize(QWidget *widget, qreal size)
 }
 
 void DebuggerPluginPrivate::fontSettingsChanged
-    (const TextEditor::FontSettings &settings)
+    (const FontSettings &settings)
 {
     if (!boolSetting(FontSizeFollowsEditor))
         return;
@@ -2013,7 +2013,7 @@ void DebuggerPluginPrivate::updateState(DebuggerEngine *engine)
         m_exitAction->setEnabled(false);
         m_startAction->setEnabled(true);
         m_debugWithoutDeployAction->setEnabled(true);
-        setProxyAction(m_visibleStartAction, Core::Id(Constants::DEBUG));
+        setProxyAction(m_visibleStartAction, Id(Constants::DEBUG));
         m_hiddenStopAction->setAction(m_undisturbableAction);
     } else if (state == InferiorStopOk) {
         // F5 continues, Shift-F5 kills. It is "continuable".
@@ -2022,7 +2022,7 @@ void DebuggerPluginPrivate::updateState(DebuggerEngine *engine)
         m_exitAction->setEnabled(true);
         m_startAction->setEnabled(false);
         m_debugWithoutDeployAction->setEnabled(false);
-        setProxyAction(m_visibleStartAction, Core::Id(Constants::CONTINUE));
+        setProxyAction(m_visibleStartAction, Id(Constants::CONTINUE));
         m_hiddenStopAction->setAction(m_exitAction);
         m_localsAndExpressionsWindow->setShowLocals(true);
     } else if (state == InferiorRunOk) {
@@ -2032,7 +2032,7 @@ void DebuggerPluginPrivate::updateState(DebuggerEngine *engine)
         m_exitAction->setEnabled(true);
         m_startAction->setEnabled(false);
         m_debugWithoutDeployAction->setEnabled(false);
-        setProxyAction(m_visibleStartAction, Core::Id(Constants::INTERRUPT));
+        setProxyAction(m_visibleStartAction, Id(Constants::INTERRUPT));
         m_hiddenStopAction->setAction(m_interruptAction);
         m_localsAndExpressionsWindow->setShowLocals(false);
     } else if (state == DebuggerFinished) {
@@ -2044,7 +2044,7 @@ void DebuggerPluginPrivate::updateState(DebuggerEngine *engine)
         m_exitAction->setEnabled(false);
         m_startAction->setEnabled(canRun);
         m_debugWithoutDeployAction->setEnabled(canRun);
-        setProxyAction(m_visibleStartAction, Core::Id(Constants::DEBUG));
+        setProxyAction(m_visibleStartAction, Id(Constants::DEBUG));
         m_hiddenStopAction->setAction(m_undisturbableAction);
         m_codeModelSnapshot = CPlusPlus::Snapshot();
         setBusyCursor(false);
@@ -2447,7 +2447,7 @@ void DebuggerPluginPrivate::extensionsInitialized()
 {
     const QKeySequence debugKey = QKeySequence(UseMacShortcuts ? tr("Ctrl+Y") : tr("F5"));
 
-    QSettings *settings = Core::ICore::settings();
+    QSettings *settings = ICore::settings();
 
     m_debuggerSettings = new DebuggerSettings;
     m_debuggerSettings->readSettings();
@@ -2733,17 +2733,17 @@ void DebuggerPluginPrivate::extensionsInitialized()
     cmd = ActionManager::registerAction(m_attachToRunningApplication,
          "Debugger.AttachToRemoteProcess", globalcontext);
     cmd->setDescription(tr("Attach to Running Application"));
-    mstart->addAction(cmd, Debugger::Constants::G_GENERAL);
+    mstart->addAction(cmd, G_GENERAL);
 
     cmd = ActionManager::registerAction(m_attachToUnstartedApplication,
           "Debugger.AttachToUnstartedProcess", globalcontext);
     cmd->setDescription(tr("Attach to Unstarted Application"));
-    mstart->addAction(cmd, Debugger::Constants::G_GENERAL);
+    mstart->addAction(cmd, G_GENERAL);
 
     cmd = ActionManager::registerAction(m_startAndDebugApplicationAction,
         "Debugger.StartAndDebugApplication", globalcontext);
     cmd->setAttribute(Command::CA_Hide);
-    mstart->addAction(cmd, Debugger::Constants::G_GENERAL);
+    mstart->addAction(cmd, G_GENERAL);
 
     cmd = ActionManager::registerAction(m_attachToCoreAction,
         "Debugger.AttachCore", globalcontext);
@@ -2976,10 +2976,10 @@ void DebuggerPluginPrivate::extensionsInitialized()
     // Debug mode setup
     DebugMode *debugMode = new DebugMode;
     QWidget *widget = m_mainWindow->createContents(debugMode);
-    Core::IContext *modeContextObject = new Core::IContext(this);
-    modeContextObject->setContext(Core::Context(CC::C_EDITORMANAGER));
+    IContext *modeContextObject = new IContext(this);
+    modeContextObject->setContext(Context(CC::C_EDITORMANAGER));
     modeContextObject->setWidget(widget);
-    Core::ICore::addContextObject(modeContextObject);
+    ICore::addContextObject(modeContextObject);
     debugMode->setWidget(widget);
 
     m_plugin->addAutoReleasedObject(debugMode);
@@ -3505,7 +3505,7 @@ void DebuggerPluginPrivate::testBenchmark1()
 {
 #ifdef WITH_BENCHMARK
     CALLGRIND_START_INSTRUMENTATION;
-    volatile Core::Id id1 = Core::Id(DEBUGGER_COMMON_SETTINGS_ID);
+    volatile Id id1 = Id(DEBUGGER_COMMON_SETTINGS_ID);
     CALLGRIND_STOP_INSTRUMENTATION;
     CALLGRIND_DUMP_STATS;
 

src/plugins/debugger/debuggerruncontrol.cpp

@@ -295,7 +295,7 @@ bool DebuggerRunControlFactory::fillParametersFromLocalRunConfiguration
     QTC_ASSERT(runConfiguration, return false);
     auto rc = qobject_cast<const LocalApplicationRunConfiguration *>(runConfiguration);
     QTC_ASSERT(rc, return false);
-    EnvironmentAspect *environmentAspect = rc->extraAspect<ProjectExplorer::EnvironmentAspect>();
+    EnvironmentAspect *environmentAspect = rc->extraAspect<EnvironmentAspect>();
     QTC_ASSERT(environmentAspect, return false);
 
     Target *target = runConfiguration->target();
@@ -331,7 +331,7 @@ bool DebuggerRunControlFactory::fillParametersFromLocalRunConfiguration
         sp->languages |= CppLanguage;
 
     if (debuggerAspect->useQmlDebugger()) {
-        const ProjectExplorer::IDevice::ConstPtr device =
+        const IDevice::ConstPtr device =
                 DeviceKitInformation::device(runConfiguration->target()->kit());
         QTC_ASSERT(device->type() == ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE, return sp);
         QTcpServer server;
@@ -491,7 +491,7 @@ bool DebuggerRunControlFactory::fillParametersFromKit(DebuggerStartParameters *s
                 sp->executable = executableForPid(sp->attachPID);
             }
             if (!sp->executable.isEmpty())
-                abis = Abi::abisOfBinary(Utils::FileName::fromString(sp->executable));
+                abis = Abi::abisOfBinary(FileName::fromString(sp->executable));
         }
         if (!abis.isEmpty()) {
             // Try exact abis.

src/plugins/debugger/disassembleragent.cpp

@@ -337,7 +337,7 @@ void DisassemblerAgent::updateBreakpointMarkers()
         return;
 
     const DisassemblerLines contents = d->contentsAtCurrentLocation();
-    foreach (TextEditor::TextMark *marker, d->breakpointMarks)
+    foreach (TextMark *marker, d->breakpointMarks)
         d->document->removeMark(marker);
     qDeleteAll(d->breakpointMarks);
     d->breakpointMarks.clear();

src/plugins/debugger/gdb/gdbengine.cpp

@@ -1063,7 +1063,7 @@ void GdbEngine::handleResultRecord(GdbResponse *response)
                 // with helpers enabled. In this case we get a second response with
                 // msg="Cannot find new threads: generic error"
                 showMessage(_("APPLYING WORKAROUND #1"));
-                Core::AsynchronousMessageBox::critical(
+                AsynchronousMessageBox::critical(
                     tr("Executable failed"), QString::fromLocal8Bit(msg));
                 showStatusMessage(tr("Process failed to start"));
                 //shutdown();
@@ -1103,7 +1103,7 @@ void GdbEngine::handleResultRecord(GdbResponse *response)
                 // long as the breakpoints are enabled.
                 // FIXME: Should we silently disable the offending breakpoints?
                 showMessage(_("APPLYING WORKAROUND #5"));
-                Core::AsynchronousMessageBox::critical(
+                AsynchronousMessageBox::critical(
                     tr("Setting breakpoints failed"), QString::fromLocal8Bit(msg));
                 QTC_CHECK(state() == InferiorRunOk);
                 notifyInferiorSpontaneousStop();
@@ -1119,7 +1119,7 @@ void GdbEngine::handleResultRecord(GdbResponse *response)
                 if (!m_lastWinException.isEmpty())
                     logMsg = m_lastWinException + QLatin1Char('\n');
                 logMsg += QString::fromLocal8Bit(msg);
-                Core::AsynchronousMessageBox::critical(tr("Executable Failed"), logMsg);
+                AsynchronousMessageBox::critical(tr("Executable Failed"), logMsg);
                 showStatusMessage(tr("Executable failed: %1").arg(logMsg));
             }
         }
@@ -1748,7 +1748,7 @@ void GdbEngine::handlePythonSetup(const GdbResponse &response)
             QString out1 = _("The selected build of GDB does not support Python scripting.");
             QString out2 = _("It cannot be used in Qt Creator.");
             showStatusMessage(out1 + QLatin1Char(' ') + out2);
-            Core::AsynchronousMessageBox::critical(tr("Execution Error"), out1 + _("<br>") + out2);
+            AsynchronousMessageBox::critical(tr("Execution Error"), out1 + _("<br>") + out2);
         }
         notifyEngineSetupFailed();
     }
@@ -1756,7 +1756,7 @@ void GdbEngine::handlePythonSetup(const GdbResponse &response)
 
 void GdbEngine::showExecutionError(const QString &message)
 {
-    Core::AsynchronousMessageBox::critical(tr("Execution Error"),
+    AsynchronousMessageBox::critical(tr("Execution Error"),
        tr("Cannot continue debugged process:") + QLatin1Char('\n') + message);
 }