diff --git a/src/plugins/clangcodemodel/clangdlocatorfilters.cpp b/src/plugins/clangcodemodel/clangdlocatorfilters.cpp
index 6cc0632234b..194e6466464 100644
--- a/src/plugins/clangcodemodel/clangdlocatorfilters.cpp
+++ b/src/plugins/clangcodemodel/clangdlocatorfilters.cpp
@@ -21,6 +21,7 @@
 #include <set>
 #include <tuple>
 
+using namespace Core;
 using namespace LanguageClient;
 using namespace LanguageServerProtocol;
 using namespace Utils;
@@ -148,11 +149,11 @@ void ClangGlobalSymbolFilter::prepareSearch(const QString &entry)
         m_lspFilter->prepareSearch(entry, clients);
 }
 
-QList<Core::LocatorFilterEntry> ClangGlobalSymbolFilter::matchesFor(
-        QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry)
+QList<LocatorFilterEntry> ClangGlobalSymbolFilter::matchesFor(
+        QFutureInterface<LocatorFilterEntry> &future, const QString &entry)
 {
-    QList<Core::LocatorFilterEntry> matches = m_cppFilter->matchesFor(future, entry);
-    const QList<Core::LocatorFilterEntry> lspMatches = m_lspFilter->matchesFor(future, entry);
+    QList<LocatorFilterEntry> matches = m_cppFilter->matchesFor(future, entry);
+    const QList<LocatorFilterEntry> lspMatches = m_lspFilter->matchesFor(future, entry);
     if (!lspMatches.isEmpty()) {
         std::set<std::tuple<FilePath, int, int>> locations;
         for (const auto &entry : std::as_const(matches)) {
@@ -174,7 +175,7 @@ QList<Core::LocatorFilterEntry> ClangGlobalSymbolFilter::matchesFor(
     return matches;
 }
 
-void ClangGlobalSymbolFilter::accept(const Core::LocatorFilterEntry &selection, QString *newText,
+void ClangGlobalSymbolFilter::accept(const LocatorFilterEntry &selection, QString *newText,
                                      int *selectionStart, int *selectionLength) const
 {
     if (qvariant_cast<CppEditor::IndexItem::Ptr>(selection.internalData))
@@ -221,10 +222,10 @@ private:
         m_content = TextEditor::TextDocument::currentTextDocument()->plainText();
     }
 
-    Core::LocatorFilterEntry generateLocatorEntry(const DocumentSymbol &info,
-                                                  const Core::LocatorFilterEntry &parent) override
+    LocatorFilterEntry generateLocatorEntry(const DocumentSymbol &info,
+                                            const LocatorFilterEntry &parent) override
     {
-        Core::LocatorFilterEntry entry;
+        LocatorFilterEntry entry;
         entry.filter = this;
         entry.displayName = ClangdClient::displayNameFromDocumentSymbol(
                     static_cast<SymbolKind>(info.kind()), info.name(),
@@ -242,22 +243,22 @@ private:
     }
 
     // Filter out declarations for which a definition is also present.
-    QList<Core::LocatorFilterEntry> matchesFor(QFutureInterface<Core::LocatorFilterEntry> &future,
-                                               const QString &entry) override
+    QList<LocatorFilterEntry> matchesFor(QFutureInterface<LocatorFilterEntry> &future,
+                                         const QString &entry) override
     {
-        QList<Core::LocatorFilterEntry> allMatches
+        QList<LocatorFilterEntry> allMatches
             = DocumentLocatorFilter::matchesFor(future, entry);
-        QHash<QString, QList<Core::LocatorFilterEntry>> possibleDuplicates;
-        for (const Core::LocatorFilterEntry &e : std::as_const(allMatches))
+        QHash<QString, QList<LocatorFilterEntry>> possibleDuplicates;
+        for (const LocatorFilterEntry &e : std::as_const(allMatches))
             possibleDuplicates[e.displayName + e.extraInfo] << e;
         const QTextDocument doc(m_content);
         for (auto it = possibleDuplicates.cbegin(); it != possibleDuplicates.cend(); ++it) {
-            const QList<Core::LocatorFilterEntry> &duplicates = it.value();
+            const QList<LocatorFilterEntry> &duplicates = it.value();
             if (duplicates.size() == 1)
                 continue;
-            QList<Core::LocatorFilterEntry> declarations;
-            QList<Core::LocatorFilterEntry> definitions;
-            for (const Core::LocatorFilterEntry &candidate : duplicates) {
+            QList<LocatorFilterEntry> declarations;
+            QList<LocatorFilterEntry> definitions;
+            for (const LocatorFilterEntry &candidate : duplicates) {
                 const auto symbol = qvariant_cast<DocumentSymbol>(candidate.internalData);
                 const SymbolKind kind = static_cast<SymbolKind>(symbol.kind());
                 if (kind != SymbolKind::Class && kind != SymbolKind::Function)
@@ -283,15 +284,15 @@ private:
             }
             if (definitions.size() == 1
                 && declarations.size() + definitions.size() == duplicates.size()) {
-                for (const Core::LocatorFilterEntry &decl : std::as_const(declarations))
-                    Utils::erase(allMatches, [&decl](const Core::LocatorFilterEntry &e) {
+                for (const LocatorFilterEntry &decl : std::as_const(declarations))
+                    Utils::erase(allMatches, [&decl](const LocatorFilterEntry &e) {
                         return e.internalData == decl.internalData;
                     });
             }
         }
 
         // The base implementation expects the position in the internal data.
-        for (Core::LocatorFilterEntry &e : allMatches) {
+        for (LocatorFilterEntry &e : allMatches) {
             const Position pos = qvariant_cast<DocumentSymbol>(e.internalData).range().start();
             e.internalData = QVariant::fromValue(Utils::LineColumn(pos.line(), pos.character()));
         }
@@ -307,10 +308,10 @@ class ClangdCurrentDocumentFilter::Private
 public:
     ~Private() { delete cppFilter; }
 
-    Core::ILocatorFilter * const cppFilter
+    ILocatorFilter * const cppFilter
             = CppEditor::CppModelManager::createAuxiliaryCurrentDocumentFilter();
     LspCurrentDocumentFilter lspFilter;
-    Core::ILocatorFilter *activeFilter = nullptr;
+    ILocatorFilter *activeFilter = nullptr;
 };
 
 
@@ -322,8 +323,8 @@ ClangdCurrentDocumentFilter::ClangdCurrentDocumentFilter() : d(new Private)
     setPriority(High);
     setDefaultIncludedByDefault(false);
     setEnabled(false);
-    connect(Core::EditorManager::instance(), &Core::EditorManager::currentEditorChanged,
-            this, [this](const Core::IEditor *editor) { setEnabled(editor); });
+    connect(EditorManager::instance(), &EditorManager::currentEditorChanged,
+            this, [this](const IEditor *editor) { setEnabled(editor); });
 }
 
 ClangdCurrentDocumentFilter::~ClangdCurrentDocumentFilter() { delete d; }
@@ -346,14 +347,14 @@ void ClangdCurrentDocumentFilter::prepareSearch(const QString &entry)
     d->activeFilter->prepareSearch(entry);
 }
 
-QList<Core::LocatorFilterEntry> ClangdCurrentDocumentFilter::matchesFor(
-        QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry)
+QList<LocatorFilterEntry> ClangdCurrentDocumentFilter::matchesFor(
+        QFutureInterface<LocatorFilterEntry> &future, const QString &entry)
 {
     QTC_ASSERT(d->activeFilter, return {});
     return d->activeFilter->matchesFor(future, entry);
 }
 
-void ClangdCurrentDocumentFilter::accept(const Core::LocatorFilterEntry &selection, QString *newText,
+void ClangdCurrentDocumentFilter::accept(const LocatorFilterEntry &selection, QString *newText,
                                          int *selectionStart, int *selectionLength) const
 {
     QTC_ASSERT(d->activeFilter, return);
diff --git a/src/plugins/cmakeprojectmanager/cmakelocatorfilter.cpp b/src/plugins/cmakeprojectmanager/cmakelocatorfilter.cpp
index ab646d1fa69..225217490cb 100644
--- a/src/plugins/cmakeprojectmanager/cmakelocatorfilter.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakelocatorfilter.cpp
@@ -17,6 +17,7 @@
 
 #include <utils/algorithm.h>
 
+using namespace Core;
 using namespace ProjectExplorer;
 using namespace Utils;
 
@@ -64,7 +65,7 @@ void CMakeTargetLocatorFilter::prepareSearch(const QString &entry)
                 extraData.insert("line", line);
                 extraData.insert("file", path.toString());
 
-                Core::LocatorFilterEntry filterEntry(this, target.title, extraData);
+                LocatorFilterEntry filterEntry(this, target.title, extraData);
                 filterEntry.extraInfo = path.shortNativePath();
                 filterEntry.highlightInfo = {index, int(entry.length())};
                 filterEntry.filePath = path;
@@ -75,7 +76,8 @@ void CMakeTargetLocatorFilter::prepareSearch(const QString &entry)
     }
 }
 
-QList<Core::LocatorFilterEntry> CMakeTargetLocatorFilter::matchesFor(QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry)
+QList<LocatorFilterEntry> CMakeTargetLocatorFilter::matchesFor(
+    QFutureInterface<LocatorFilterEntry> &future, const QString &entry)
 {
     Q_UNUSED(future)
     Q_UNUSED(entry)
@@ -85,7 +87,8 @@ QList<Core::LocatorFilterEntry> CMakeTargetLocatorFilter::matchesFor(QFutureInte
 void CMakeTargetLocatorFilter::projectListUpdated()
 {
     // Enable the filter if there's at least one CMake project
-    setEnabled(Utils::contains(SessionManager::projects(), [](Project *p) { return qobject_cast<CMakeProject *>(p); }));
+    setEnabled(Utils::contains(SessionManager::projects(),
+                               [](Project *p) { return qobject_cast<CMakeProject *>(p); }));
 }
 
 // --------------------------------------------------------------------
@@ -101,10 +104,8 @@ BuildCMakeTargetLocatorFilter::BuildCMakeTargetLocatorFilter()
     setPriority(High);
 }
 
-void BuildCMakeTargetLocatorFilter::accept(const Core::LocatorFilterEntry &selection,
-                                           QString *newText,
-                                           int *selectionStart,
-                                           int *selectionLength) const
+void BuildCMakeTargetLocatorFilter::accept(const LocatorFilterEntry &selection, QString *newText,
+                                           int *selectionStart, int *selectionLength) const
 {
     Q_UNUSED(newText)
     Q_UNUSED(selectionStart)
@@ -151,7 +152,7 @@ OpenCMakeTargetLocatorFilter::OpenCMakeTargetLocatorFilter()
     setPriority(Medium);
 }
 
-void OpenCMakeTargetLocatorFilter::accept(const Core::LocatorFilterEntry &selection,
+void OpenCMakeTargetLocatorFilter::accept(const LocatorFilterEntry &selection,
                                           QString *newText,
                                           int *selectionStart,
                                           int *selectionLength) const
@@ -165,11 +166,9 @@ void OpenCMakeTargetLocatorFilter::accept(const Core::LocatorFilterEntry &select
     const auto file = FilePath::fromVariant(extraData.value("file"));
 
     if (line >= 0)
-        Core::EditorManager::openEditorAt({file, line},
-                                          {},
-                                          Core::EditorManager::AllowExternalEditor);
+        EditorManager::openEditorAt({file, line}, {}, EditorManager::AllowExternalEditor);
     else
-        Core::EditorManager::openEditor(file, {}, Core::EditorManager::AllowExternalEditor);
+        EditorManager::openEditor(file, {}, EditorManager::AllowExternalEditor);
 }
 
 } // CMakeProjectManager::Internal
diff --git a/src/plugins/cppeditor/cppcurrentdocumentfilter.cpp b/src/plugins/cppeditor/cppcurrentdocumentfilter.cpp
index d6687284588..a52edbfce52 100644
--- a/src/plugins/cppeditor/cppcurrentdocumentfilter.cpp
+++ b/src/plugins/cppeditor/cppcurrentdocumentfilter.cpp
@@ -15,6 +15,7 @@
 #include <QHash>
 #include <QRegularExpression>
 
+using namespace Core;
 using namespace CPlusPlus;
 
 namespace CppEditor::Internal {
@@ -35,9 +36,9 @@ CppCurrentDocumentFilter::CppCurrentDocumentFilter(CppModelManager *manager)
 
     connect(manager, &CppModelManager::documentUpdated,
             this, &CppCurrentDocumentFilter::onDocumentUpdated);
-    connect(Core::EditorManager::instance(), &Core::EditorManager::currentEditorChanged,
+    connect(EditorManager::instance(), &EditorManager::currentEditorChanged,
             this, &CppCurrentDocumentFilter::onCurrentEditorChanged);
-    connect(Core::EditorManager::instance(), &Core::EditorManager::editorAboutToClose,
+    connect(EditorManager::instance(), &EditorManager::editorAboutToClose,
             this, &CppCurrentDocumentFilter::onEditorAboutToClose);
 }
 
@@ -50,11 +51,11 @@ void CppCurrentDocumentFilter::makeAuxiliary()
     setHidden(true);
 }
 
-QList<Core::LocatorFilterEntry> CppCurrentDocumentFilter::matchesFor(
-        QFutureInterface<Core::LocatorFilterEntry> &future, const QString & entry)
+QList<LocatorFilterEntry> CppCurrentDocumentFilter::matchesFor(
+        QFutureInterface<LocatorFilterEntry> &future, const QString & entry)
 {
-    QList<Core::LocatorFilterEntry> goodEntries;
-    QList<Core::LocatorFilterEntry> betterEntries;
+    QList<LocatorFilterEntry> goodEntries;
+    QList<LocatorFilterEntry> betterEntries;
 
     const QRegularExpression regexp = createRegExp(entry);
     if (!regexp.isValid())
@@ -84,14 +85,14 @@ QList<Core::LocatorFilterEntry> CppCurrentDocumentFilter::matchesFor(
                 }
             }
 
-            Core::LocatorFilterEntry filterEntry(this, name, id, info->icon());
+            LocatorFilterEntry filterEntry(this, name, id, info->icon());
             filterEntry.extraInfo = extraInfo;
             if (match.hasMatch()) {
                 filterEntry.highlightInfo = highlightInfo(match);
             } else {
                 match = regexp.match(extraInfo);
                 filterEntry.highlightInfo =
-                        highlightInfo(match, Core::LocatorFilterEntry::HighlightInfo::ExtraInfo);
+                        highlightInfo(match, LocatorFilterEntry::HighlightInfo::ExtraInfo);
             }
 
             if (betterMatch)
@@ -104,18 +105,18 @@ QList<Core::LocatorFilterEntry> CppCurrentDocumentFilter::matchesFor(
     // entries are unsorted by design!
     betterEntries += goodEntries;
 
-    QHash<QString, QList<Core::LocatorFilterEntry>> possibleDuplicates;
-    for (const Core::LocatorFilterEntry &e : std::as_const(betterEntries)) {
+    QHash<QString, QList<LocatorFilterEntry>> possibleDuplicates;
+    for (const LocatorFilterEntry &e : std::as_const(betterEntries)) {
         const IndexItem::Ptr info = qvariant_cast<IndexItem::Ptr>(e.internalData);
         possibleDuplicates[info->scopedSymbolName() + info->symbolType()] << e;
     }
     for (auto it = possibleDuplicates.cbegin(); it != possibleDuplicates.cend(); ++it) {
-        const QList<Core::LocatorFilterEntry> &duplicates = it.value();
+        const QList<LocatorFilterEntry> &duplicates = it.value();
         if (duplicates.size() == 1)
             continue;
-        QList<Core::LocatorFilterEntry> declarations;
-        QList<Core::LocatorFilterEntry> definitions;
-        for (const Core::LocatorFilterEntry &candidate : duplicates) {
+        QList<LocatorFilterEntry> declarations;
+        QList<LocatorFilterEntry> definitions;
+        for (const LocatorFilterEntry &candidate : duplicates) {
             const IndexItem::Ptr info = qvariant_cast<IndexItem::Ptr>(candidate.internalData);
             if (info->type() != IndexItem::Function)
                 break;
@@ -126,8 +127,8 @@ QList<Core::LocatorFilterEntry> CppCurrentDocumentFilter::matchesFor(
         }
         if (definitions.size() == 1
             && declarations.size() + definitions.size() == duplicates.size()) {
-            for (const Core::LocatorFilterEntry &decl : std::as_const(declarations))
-                Utils::erase(betterEntries, [&decl](const Core::LocatorFilterEntry &e) {
+            for (const LocatorFilterEntry &decl : std::as_const(declarations))
+                Utils::erase(betterEntries, [&decl](const LocatorFilterEntry &e) {
                     return e.internalData == decl.internalData;
                 });
         }
@@ -136,15 +137,14 @@ QList<Core::LocatorFilterEntry> CppCurrentDocumentFilter::matchesFor(
     return betterEntries;
 }
 
-void CppCurrentDocumentFilter::accept(const Core::LocatorFilterEntry &selection,
-                                      QString *newText, int *selectionStart,
-                                      int *selectionLength) const
+void CppCurrentDocumentFilter::accept(const LocatorFilterEntry &selection, QString *newText,
+                                      int *selectionStart, int *selectionLength) const
 {
     Q_UNUSED(newText)
     Q_UNUSED(selectionStart)
     Q_UNUSED(selectionLength)
     IndexItem::Ptr info = qvariant_cast<IndexItem::Ptr>(selection.internalData);
-    Core::EditorManager::openEditorAt({info->filePath(), info->line(), info->column()});
+    EditorManager::openEditorAt({info->filePath(), info->line(), info->column()});
 }
 
 void CppCurrentDocumentFilter::onDocumentUpdated(Document::Ptr doc)
@@ -154,7 +154,7 @@ void CppCurrentDocumentFilter::onDocumentUpdated(Document::Ptr doc)
         m_itemsOfCurrentDoc.clear();
 }
 
-void CppCurrentDocumentFilter::onCurrentEditorChanged(Core::IEditor *currentEditor)
+void CppCurrentDocumentFilter::onCurrentEditorChanged(IEditor *currentEditor)
 {
     QMutexLocker locker(&m_mutex);
     if (currentEditor)
@@ -164,7 +164,7 @@ void CppCurrentDocumentFilter::onCurrentEditorChanged(Core::IEditor *currentEdit
     m_itemsOfCurrentDoc.clear();
 }
 
-void CppCurrentDocumentFilter::onEditorAboutToClose(Core::IEditor *editorAboutToClose)
+void CppCurrentDocumentFilter::onEditorAboutToClose(IEditor *editorAboutToClose)
 {
     if (!editorAboutToClose)
         return;
diff --git a/src/plugins/cppeditor/cpplocatorfilter.cpp b/src/plugins/cppeditor/cpplocatorfilter.cpp
index 083c5df1b2f..c6567165910 100644
--- a/src/plugins/cppeditor/cpplocatorfilter.cpp
+++ b/src/plugins/cppeditor/cpplocatorfilter.cpp
@@ -14,6 +14,8 @@
 #include <algorithm>
 #include <numeric>
 
+using namespace Core;
+
 namespace CppEditor {
 
 CppLocatorFilter::CppLocatorFilter(CppLocatorData *locatorData)
@@ -27,10 +29,10 @@ CppLocatorFilter::CppLocatorFilter(CppLocatorData *locatorData)
 
 CppLocatorFilter::~CppLocatorFilter() = default;
 
-Core::LocatorFilterEntry CppLocatorFilter::filterEntryFromIndexItem(IndexItem::Ptr info)
+LocatorFilterEntry CppLocatorFilter::filterEntryFromIndexItem(IndexItem::Ptr info)
 {
     const QVariant id = QVariant::fromValue(info);
-    Core::LocatorFilterEntry filterEntry(this, info->scopedSymbolName(), id, info->icon());
+    LocatorFilterEntry filterEntry(this, info->scopedSymbolName(), id, info->icon());
     if (info->type() == IndexItem::Class || info->type() == IndexItem::Enum)
         filterEntry.extraInfo = info->shortNativeFilePath();
     else
@@ -39,10 +41,10 @@ Core::LocatorFilterEntry CppLocatorFilter::filterEntryFromIndexItem(IndexItem::P
     return filterEntry;
 }
 
-QList<Core::LocatorFilterEntry> CppLocatorFilter::matchesFor(
-        QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry)
+QList<LocatorFilterEntry> CppLocatorFilter::matchesFor(
+        QFutureInterface<LocatorFilterEntry> &future, const QString &entry)
 {
-    QList<Core::LocatorFilterEntry> entries[int(MatchLevel::Count)];
+    QList<LocatorFilterEntry> entries[int(MatchLevel::Count)];
     const Qt::CaseSensitivity caseSensitivityForPrefix = caseSensitivity(entry);
     const IndexItem::ItemType wanted = matchTypes();
 
@@ -70,7 +72,7 @@ QList<Core::LocatorFilterEntry> CppLocatorFilter::matchesFor(
             }
 
             if (match.hasMatch()) {
-                Core::LocatorFilterEntry filterEntry = filterEntryFromIndexItem(info);
+                LocatorFilterEntry filterEntry = filterEntryFromIndexItem(info);
 
                 // Highlight the matched characters, therefore it may be necessary
                 // to update the match if the displayName is different from matchString
@@ -82,7 +84,7 @@ QList<Core::LocatorFilterEntry> CppLocatorFilter::matchesFor(
                 if (matchInParameterList && filterEntry.highlightInfo.startsDisplay.isEmpty()) {
                     match = regexp.match(filterEntry.extraInfo);
                     filterEntry.highlightInfo
-                        = highlightInfo(match, Core::LocatorFilterEntry::HighlightInfo::ExtraInfo);
+                        = highlightInfo(match, LocatorFilterEntry::HighlightInfo::ExtraInfo);
                 } else if (matchOffset > 0) {
                     for (int &start : filterEntry.highlightInfo.startsDisplay)
                         start -= matchOffset;
@@ -107,22 +109,21 @@ QList<Core::LocatorFilterEntry> CppLocatorFilter::matchesFor(
 
     for (auto &entry : entries) {
         if (entry.size() < 1000)
-            Utils::sort(entry, Core::LocatorFilterEntry::compareLexigraphically);
+            Utils::sort(entry, LocatorFilterEntry::compareLexigraphically);
     }
 
-    return std::accumulate(std::begin(entries), std::end(entries), QList<Core::LocatorFilterEntry>());
+    return std::accumulate(std::begin(entries), std::end(entries), QList<LocatorFilterEntry>());
 }
 
-void CppLocatorFilter::accept(const Core::LocatorFilterEntry &selection,
+void CppLocatorFilter::accept(const LocatorFilterEntry &selection,
                               QString *newText, int *selectionStart, int *selectionLength) const
 {
     Q_UNUSED(newText)
     Q_UNUSED(selectionStart)
     Q_UNUSED(selectionLength)
     IndexItem::Ptr info = qvariant_cast<IndexItem::Ptr>(selection.internalData);
-    Core::EditorManager::openEditorAt({info->filePath(), info->line(), info->column()},
-                                      {},
-                                      Core::EditorManager::AllowExternalEditor);
+    EditorManager::openEditorAt({info->filePath(), info->line(), info->column()}, {},
+                                EditorManager::AllowExternalEditor);
 }
 
 CppClassesFilter::CppClassesFilter(CppLocatorData *locatorData)
@@ -136,10 +137,10 @@ CppClassesFilter::CppClassesFilter(CppLocatorData *locatorData)
 
 CppClassesFilter::~CppClassesFilter() = default;
 
-Core::LocatorFilterEntry CppClassesFilter::filterEntryFromIndexItem(IndexItem::Ptr info)
+LocatorFilterEntry CppClassesFilter::filterEntryFromIndexItem(IndexItem::Ptr info)
 {
     const QVariant id = QVariant::fromValue(info);
-    Core::LocatorFilterEntry filterEntry(this, info->symbolName(), id, info->icon());
+    LocatorFilterEntry filterEntry(this, info->symbolName(), id, info->icon());
     filterEntry.extraInfo = info->symbolScope().isEmpty()
         ? info->shortNativeFilePath()
         : info->symbolScope();
@@ -158,7 +159,7 @@ CppFunctionsFilter::CppFunctionsFilter(CppLocatorData *locatorData)
 
 CppFunctionsFilter::~CppFunctionsFilter() = default;
 
-Core::LocatorFilterEntry CppFunctionsFilter::filterEntryFromIndexItem(IndexItem::Ptr info)
+LocatorFilterEntry CppFunctionsFilter::filterEntryFromIndexItem(IndexItem::Ptr info)
 {
     const QVariant id = QVariant::fromValue(info);
 
@@ -171,7 +172,7 @@ Core::LocatorFilterEntry CppFunctionsFilter::filterEntryFromIndexItem(IndexItem:
         extraInfo.append(" (" + info->filePath().fileName() + ')');
     }
 
-    Core::LocatorFilterEntry filterEntry(this, name + info->symbolType(), id, info->icon());
+    LocatorFilterEntry filterEntry(this, name + info->symbolType(), id, info->icon());
     filterEntry.extraInfo = extraInfo;
 
     return filterEntry;
diff --git a/src/plugins/cppeditor/cppmodelmanager.cpp b/src/plugins/cppeditor/cppmodelmanager.cpp
index 8fc44622ab2..373773786a9 100644
--- a/src/plugins/cppeditor/cppmodelmanager.cpp
+++ b/src/plugins/cppeditor/cppmodelmanager.cpp
@@ -90,6 +90,7 @@
 #include <sstream>
 #endif
 
+using namespace Core;
 using namespace CPlusPlus;
 using namespace ProjectExplorer;
 using namespace Utils;
@@ -155,7 +156,7 @@ public:
 class CppModelManagerPrivate
 {
 public:
-    void setupWatcher(const QFuture<void> &future, ProjectExplorer::Project *project,
+    void setupWatcher(const QFuture<void> &future, Project *project,
                       ProjectData *projectData, CppModelManager *q);
 
     // Snapshot
@@ -164,15 +165,15 @@ public:
 
     // Project integration
     QReadWriteLock m_projectLock;
-    QHash<ProjectExplorer::Project *, ProjectData> m_projectData;
-    QMap<Utils::FilePath, QList<ProjectPart::ConstPtr> > m_fileToProjectParts;
+    QHash<Project *, ProjectData> m_projectData;
+    QMap<FilePath, QList<ProjectPart::ConstPtr> > m_fileToProjectParts;
     QMap<QString, ProjectPart::ConstPtr> m_projectPartIdToProjectProjectPart;
 
     // The members below are cached/(re)calculated from the projects and/or their project parts
     bool m_dirty;
-    Utils::FilePaths m_projectFiles;
-    ProjectExplorer::HeaderPaths m_headerPaths;
-    ProjectExplorer::Macros m_definedMacros;
+    FilePaths m_projectFiles;
+    HeaderPaths m_headerPaths;
+    Macros m_definedMacros;
 
     // Editor integration
     mutable QMutex m_cppEditorDocumentsMutex;
@@ -201,12 +202,12 @@ public:
     QTimer m_fallbackProjectPartTimer;
 
     CppLocatorData m_locatorData;
-    std::unique_ptr<Core::ILocatorFilter> m_locatorFilter;
-    std::unique_ptr<Core::ILocatorFilter> m_classesFilter;
-    std::unique_ptr<Core::ILocatorFilter> m_includesFilter;
-    std::unique_ptr<Core::ILocatorFilter> m_functionsFilter;
-    std::unique_ptr<Core::IFindFilter> m_symbolsFindFilter;
-    std::unique_ptr<Core::ILocatorFilter> m_currentDocumentFilter;
+    std::unique_ptr<ILocatorFilter> m_locatorFilter;
+    std::unique_ptr<ILocatorFilter> m_classesFilter;
+    std::unique_ptr<ILocatorFilter> m_includesFilter;
+    std::unique_ptr<ILocatorFilter> m_functionsFilter;
+    std::unique_ptr<IFindFilter> m_symbolsFindFilter;
+    std::unique_ptr<ILocatorFilter> m_currentDocumentFilter;
 
     QList<Document::DiagnosticMessage> m_diagnosticMessages;
 };
@@ -338,7 +339,7 @@ void CppModelManager::findUsages(const CursorInEditor &data, Backend backend)
 
 void CppModelManager::switchHeaderSource(bool inNextSplit, Backend backend)
 {
-    const Core::IDocument *currentDocument = Core::EditorManager::currentDocument();
+    const IDocument *currentDocument = EditorManager::currentDocument();
     QTC_ASSERT(currentDocument, return);
     instance()->modelManagerSupport(backend)->switchHeaderSource(currentDocument->filePath(),
                                                                  inNextSplit);
@@ -346,16 +347,16 @@ void CppModelManager::switchHeaderSource(bool inNextSplit, Backend backend)
 
 void CppModelManager::showPreprocessedFile(bool inNextSplit)
 {
-    const Core::IDocument *doc = Core::EditorManager::currentDocument();
+    const IDocument *doc = EditorManager::currentDocument();
     QTC_ASSERT(doc, return);
 
     static const auto showError = [](const QString &reason) {
-        Core::MessageManager::writeFlashing(Tr::tr("Cannot show preprocessed file: %1")
-                                            .arg(reason));
+        MessageManager::writeFlashing(Tr::tr("Cannot show preprocessed file: %1")
+                                          .arg(reason));
     };
     static const auto showFallbackWarning = [](const QString &reason) {
-        Core::MessageManager::writeSilently(
-            Tr::tr("Falling back to built-in preprocessor: %1").arg(reason));
+        MessageManager::writeSilently(Tr::tr("Falling back to built-in preprocessor: %1")
+                                          .arg(reason));
     };
     static const auto saveAndOpen = [](const FilePath &filePath, const QByteArray &contents,
                                        bool inNextSplit) {
@@ -469,24 +470,24 @@ class FindUnusedActionsEnabledSwitcher
 {
 public:
     FindUnusedActionsEnabledSwitcher()
-        : actions{Core::ActionManager::command("CppTools.FindUnusedFunctions"),
-                  Core::ActionManager::command("CppTools.FindUnusedFunctionsInSubProject")}
+        : actions{ActionManager::command("CppTools.FindUnusedFunctions"),
+                  ActionManager::command("CppTools.FindUnusedFunctionsInSubProject")}
     {
-        for (Core::Command * const action : actions)
+        for (Command * const action : actions)
             action->action()->setEnabled(false);
     }
     ~FindUnusedActionsEnabledSwitcher()
     {
-        for (Core::Command * const action : actions)
+        for (Command * const action : actions)
             action->action()->setEnabled(true);
     }
 private:
-    const QList<Core::Command *> actions;
+    const QList<Command *> actions;
 };
 using FindUnusedActionsEnabledSwitcherPtr = std::shared_ptr<FindUnusedActionsEnabledSwitcher>;
 
 static void checkNextFunctionForUnused(
-        const QPointer<Core::SearchResult> &search,
+        const QPointer<SearchResult> &search,
         const std::shared_ptr<QFutureInterface<bool>> &findRefsFuture,
         const FindUnusedActionsEnabledSwitcherPtr &actionsSwitcher)
 {
@@ -531,30 +532,28 @@ void CppModelManager::findUnusedFunctions(const FilePath &folder)
     const auto actionsSwitcher = std::make_shared<FindUnusedActionsEnabledSwitcher>();
 
     // Step 1: Employ locator to find all functions
-    Core::ILocatorFilter *const functionsFilter
-            = Utils::findOrDefault(Core::ILocatorFilter::allLocatorFilters(),
-                                   Utils::equal(&Core::ILocatorFilter::id,
+    ILocatorFilter *const functionsFilter
+            = Utils::findOrDefault(ILocatorFilter::allLocatorFilters(),
+                                   Utils::equal(&ILocatorFilter::id,
                                                 Id(Constants::FUNCTIONS_FILTER_ID)));
     QTC_ASSERT(functionsFilter, return);
-    const QPointer<Core::SearchResult> search
-            = Core::SearchResultWindow::instance()
-            ->startNewSearch(Tr::tr("Find Unused Functions"),
+    const QPointer<SearchResult> search
+        = SearchResultWindow::instance()->startNewSearch(Tr::tr("Find Unused Functions"),
                              {},
                              {},
-                             Core::SearchResultWindow::SearchOnly,
-                             Core::SearchResultWindow::PreserveCaseDisabled,
+                             SearchResultWindow::SearchOnly,
+                             SearchResultWindow::PreserveCaseDisabled,
                              "CppEditor");
-    connect(search, &Core::SearchResult::activated, [](const Core::SearchResultItem &item) {
-        Core::EditorManager::openEditorAtSearchResult(item);
+    connect(search, &SearchResult::activated, [](const SearchResultItem &item) {
+        EditorManager::openEditorAtSearchResult(item);
     });
-    Core::SearchResultWindow::instance()->popup(Core::IOutputPane::ModeSwitch
-                                                | Core::IOutputPane::WithFocus);
-    const auto locatorWatcher = new QFutureWatcher<Core::LocatorFilterEntry>(search);
+    SearchResultWindow::instance()->popup(IOutputPane::ModeSwitch | IOutputPane::WithFocus);
+    const auto locatorWatcher = new QFutureWatcher<LocatorFilterEntry>(search);
     functionsFilter->prepareSearch({});
-    connect(search, &Core::SearchResult::canceled, locatorWatcher, [locatorWatcher] {
+    connect(search, &SearchResult::canceled, locatorWatcher, [locatorWatcher] {
         locatorWatcher->cancel();
     });
-    connect(locatorWatcher, &QFutureWatcher<Core::LocatorFilterEntry>::finished, search,
+    connect(locatorWatcher, &QFutureWatcher<LocatorFilterEntry>::finished, search,
             [locatorWatcher, search, folder, actionsSwitcher] {
         locatorWatcher->deleteLater();
         if (locatorWatcher->isCanceled()) {
@@ -563,7 +562,7 @@ void CppModelManager::findUnusedFunctions(const FilePath &folder)
         }
         Links links;
         for (int i = 0; i < locatorWatcher->future().resultCount(); ++i) {
-            const Core::LocatorFilterEntry &entry = locatorWatcher->resultAt(i);
+            const LocatorFilterEntry &entry = locatorWatcher->resultAt(i);
             static const QStringList prefixBlacklist{"main(", "~", "qHash(", "begin()", "end()",
                     "cbegin()", "cend()", "constBegin()", "constEnd()"};
             if (Utils::anyOf(prefixBlacklist, [&entry](const QString &prefix) {
@@ -593,12 +592,11 @@ void CppModelManager::findUnusedFunctions(const FilePath &folder)
         }));
         search->setUserData(remainingAndActiveLinks);
         const auto findRefsFuture = std::make_shared<QFutureInterface<bool>>();
-        Core::FutureProgress *const progress
-                = Core::ProgressManager::addTask(findRefsFuture->future(),
-                                                 Tr::tr("Finding Unused Functions"),
-                                                 "CppEditor.FindUnusedFunctions");
+        FutureProgress *const progress = ProgressManager::addTask(findRefsFuture->future(),
+                                                          Tr::tr("Finding Unused Functions"),
+                                                          "CppEditor.FindUnusedFunctions");
         connect(progress,
-                &Core::FutureProgress::canceled,
+                &FutureProgress::canceled,
                 search,
                 [search, future = std::weak_ptr<QFutureInterface<bool>>(findRefsFuture)] {
             search->finishSearch(true);
@@ -608,7 +606,7 @@ void CppModelManager::findUnusedFunctions(const FilePath &folder)
             }
         });
         findRefsFuture->setProgressRange(0, links.size());
-        connect(search, &Core::SearchResult::canceled, [findRefsFuture] {
+        connect(search, &SearchResult::canceled, [findRefsFuture] {
             findRefsFuture->cancel();
             findRefsFuture->reportFinished();
         });
@@ -620,12 +618,12 @@ void CppModelManager::findUnusedFunctions(const FilePath &folder)
             checkNextFunctionForUnused(search, findRefsFuture, actionsSwitcher);
     });
     locatorWatcher->setFuture(
-                Utils::runAsync([functionsFilter](QFutureInterface<Core::LocatorFilterEntry> &future) {
+                Utils::runAsync([functionsFilter](QFutureInterface<LocatorFilterEntry> &future) {
                     future.reportResults(functionsFilter->matchesFor(future, {}));
                 }));
 }
 
-void CppModelManager::checkForUnusedSymbol(Core::SearchResult *search,
+void CppModelManager::checkForUnusedSymbol(SearchResult *search,
                                            const Link &link,
                                            CPlusPlus::Symbol *symbol,
                                            const CPlusPlus::LookupContext &context,
@@ -785,62 +783,62 @@ static void setFilter(std::unique_ptr<FilterClass> &filter,
     filter = std::move(newFilter);
 }
 
-void CppModelManager::setLocatorFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+void CppModelManager::setLocatorFilter(std::unique_ptr<ILocatorFilter> &&filter)
 {
     setFilter(d->m_locatorFilter, std::move(filter));
 }
 
-void CppModelManager::setClassesFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+void CppModelManager::setClassesFilter(std::unique_ptr<ILocatorFilter> &&filter)
 {
     setFilter(d->m_classesFilter, std::move(filter));
 }
 
-void CppModelManager::setIncludesFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+void CppModelManager::setIncludesFilter(std::unique_ptr<ILocatorFilter> &&filter)
 {
     setFilter(d->m_includesFilter, std::move(filter));
 }
 
-void CppModelManager::setFunctionsFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+void CppModelManager::setFunctionsFilter(std::unique_ptr<ILocatorFilter> &&filter)
 {
     setFilter(d->m_functionsFilter, std::move(filter));
 }
 
-void CppModelManager::setSymbolsFindFilter(std::unique_ptr<Core::IFindFilter> &&filter)
+void CppModelManager::setSymbolsFindFilter(std::unique_ptr<IFindFilter> &&filter)
 {
     setFilter(d->m_symbolsFindFilter, std::move(filter));
 }
 
-void CppModelManager::setCurrentDocumentFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+void CppModelManager::setCurrentDocumentFilter(std::unique_ptr<ILocatorFilter> &&filter)
 {
     setFilter(d->m_currentDocumentFilter, std::move(filter));
 }
 
-Core::ILocatorFilter *CppModelManager::locatorFilter() const
+ILocatorFilter *CppModelManager::locatorFilter() const
 {
     return d->m_locatorFilter.get();
 }
 
-Core::ILocatorFilter *CppModelManager::classesFilter() const
+ILocatorFilter *CppModelManager::classesFilter() const
 {
     return d->m_classesFilter.get();
 }
 
-Core::ILocatorFilter *CppModelManager::includesFilter() const
+ILocatorFilter *CppModelManager::includesFilter() const
 {
     return d->m_includesFilter.get();
 }
 
-Core::ILocatorFilter *CppModelManager::functionsFilter() const
+ILocatorFilter *CppModelManager::functionsFilter() const
 {
     return d->m_functionsFilter.get();
 }
 
-Core::IFindFilter *CppModelManager::symbolsFindFilter() const
+IFindFilter *CppModelManager::symbolsFindFilter() const
 {
     return d->m_symbolsFindFilter.get();
 }
 
-Core::ILocatorFilter *CppModelManager::currentDocumentFilter() const
+ILocatorFilter *CppModelManager::currentDocumentFilter() const
 {
     return d->m_currentDocumentFilter.get();
 }
@@ -880,7 +878,7 @@ CppModelManager *CppModelManager::instance()
 
 void CppModelManager::registerJsExtension()
 {
-    Core::JsExpander::registerGlobalObject("Cpp", [this] {
+    JsExpander::registerGlobalObject("Cpp", [this] {
         return new CppToolsJsExtension(&d->m_locatorData);
     });
 }
@@ -888,9 +886,9 @@ void CppModelManager::registerJsExtension()
 void CppModelManager::initCppTools()
 {
     // Objects
-    connect(Core::VcsManager::instance(), &Core::VcsManager::repositoryChanged,
+    connect(VcsManager::instance(), &VcsManager::repositoryChanged,
             this, &CppModelManager::updateModifiedSourceFiles);
-    connect(Core::DocumentManager::instance(), &Core::DocumentManager::filesChangedInternally,
+    connect(DocumentManager::instance(), &DocumentManager::filesChangedInternally,
             [this](const FilePaths &filePaths) {
         updateSourceFiles(toSet(filePaths));
     });
@@ -924,7 +922,7 @@ CppModelManager::CppModelManager()
     d->m_enableGC = true;
 
     // Visual C++ has 1MiB, macOSX has 512KiB
-    if (Utils::HostOsInfo::isWindowsHost() || Utils::HostOsInfo::isMacHost())
+    if (HostOsInfo::isWindowsHost() || HostOsInfo::isMacHost())
         d->m_threadPool.setStackSize(2 * 1024 * 1024);
 
     qRegisterMetaType<QSet<QString> >();
@@ -940,23 +938,23 @@ CppModelManager::CppModelManager()
     d->m_delayedGcTimer.setSingleShot(true);
     connect(&d->m_delayedGcTimer, &QTimer::timeout, this, &CppModelManager::GC);
 
-    auto sessionManager = ProjectExplorer::SessionManager::instance();
-    connect(sessionManager, &ProjectExplorer::SessionManager::projectAdded,
+    auto sessionManager = SessionManager::instance();
+    connect(sessionManager, &SessionManager::projectAdded,
             this, &CppModelManager::onProjectAdded);
-    connect(sessionManager, &ProjectExplorer::SessionManager::aboutToRemoveProject,
+    connect(sessionManager, &SessionManager::aboutToRemoveProject,
             this, &CppModelManager::onAboutToRemoveProject);
-    connect(sessionManager, &ProjectExplorer::SessionManager::aboutToLoadSession,
+    connect(sessionManager, &SessionManager::aboutToLoadSession,
             this, &CppModelManager::onAboutToLoadSession);
-    connect(sessionManager, &ProjectExplorer::SessionManager::startupProjectChanged,
+    connect(sessionManager, &SessionManager::startupProjectChanged,
             this, &CppModelManager::onActiveProjectChanged);
 
-    connect(Core::EditorManager::instance(), &Core::EditorManager::currentEditorChanged,
+    connect(EditorManager::instance(), &EditorManager::currentEditorChanged,
             this, &CppModelManager::onCurrentEditorChanged);
 
-    connect(Core::DocumentManager::instance(), &Core::DocumentManager::allDocumentsRenamed,
+    connect(DocumentManager::instance(), &DocumentManager::allDocumentsRenamed,
             this, &CppModelManager::renameIncludes);
 
-    connect(Core::ICore::instance(), &Core::ICore::coreAboutToClose,
+    connect(ICore::instance(), &ICore::coreAboutToClose,
             this, &CppModelManager::onCoreAboutToClose);
 
     d->m_fallbackProjectPartTimer.setSingleShot(true);
@@ -1041,13 +1039,13 @@ FilePaths CppModelManager::internalProjectFiles() const
     return files;
 }
 
-ProjectExplorer::HeaderPaths CppModelManager::internalHeaderPaths() const
+HeaderPaths CppModelManager::internalHeaderPaths() const
 {
-    ProjectExplorer::HeaderPaths headerPaths;
+    HeaderPaths headerPaths;
     for (const ProjectData &projectData: std::as_const(d->m_projectData)) {
         for (const ProjectPart::ConstPtr &part : projectData.projectInfo->projectParts()) {
-            for (const ProjectExplorer::HeaderPath &path : part->headerPaths) {
-                ProjectExplorer::HeaderPath hp(QDir::cleanPath(path.path), path.type);
+            for (const HeaderPath &path : part->headerPaths) {
+                HeaderPath hp(QDir::cleanPath(path.path), path.type);
                 if (!headerPaths.contains(hp))
                     headerPaths.push_back(std::move(hp));
             }
@@ -1056,8 +1054,7 @@ ProjectExplorer::HeaderPaths CppModelManager::internalHeaderPaths() const
     return headerPaths;
 }
 
-static void addUnique(const ProjectExplorer::Macros &newMacros,
-                      ProjectExplorer::Macros &macros,
+static void addUnique(const Macros &newMacros, Macros &macros,
                       QSet<ProjectExplorer::Macro> &alreadyIn)
 {
     for (const ProjectExplorer::Macro &macro : newMacros) {
@@ -1068,9 +1065,9 @@ static void addUnique(const ProjectExplorer::Macros &newMacros,
     }
 }
 
-ProjectExplorer::Macros CppModelManager::internalDefinedMacros() const
+Macros CppModelManager::internalDefinedMacros() const
 {
-    ProjectExplorer::Macros macros;
+    Macros macros;
     QSet<ProjectExplorer::Macro> alreadyIn;
     for (const ProjectData &projectData : std::as_const(d->m_projectData)) {
         for (const ProjectPart::ConstPtr &part : projectData.projectInfo->projectParts()) {
@@ -1093,7 +1090,7 @@ void CppModelManager::dumpModelManagerConfiguration(const QString &logFileId)
     dumper.dumpSnapshot(globalSnapshot, globalSnapshotTitle, /*isGlobalSnapshot=*/ true);
     dumper.dumpWorkingCopy(workingCopy());
     dumper.dumpMergedEntities(headerPaths(),
-                              ProjectExplorer:: Macro::toByteArray(definedMacros()));
+                              ProjectExplorer::Macro::toByteArray(definedMacros()));
 }
 
 QSet<AbstractEditorSupport *> CppModelManager::abstractEditorSupports() const
@@ -1268,8 +1265,8 @@ static QSet<QString> filteredFilesRemoved(const QSet<QString> &files, int fileSi
                     const QString msg = Tr::tr("C++ Indexer: Skipping file \"%1\" "
                                                "because its path matches the ignore pattern.")
                                     .arg(filePath.displayName());
-                    QMetaObject::invokeMethod(Core::MessageManager::instance(),
-                                              [msg]() { Core::MessageManager::writeSilently(msg); });
+                    QMetaObject::invokeMethod(MessageManager::instance(),
+                                              [msg] { MessageManager::writeSilently(msg); });
                     skip = true;
                     break;
                 }
@@ -1304,7 +1301,7 @@ ProjectInfoList CppModelManager::projectInfos() const
             [](const ProjectData &d) { return d.projectInfo; });
 }
 
-ProjectInfo::ConstPtr CppModelManager::projectInfo(ProjectExplorer::Project *project) const
+ProjectInfo::ConstPtr CppModelManager::projectInfo(Project *project) const
 {
     QReadLocker locker(&d->m_projectLock);
     return d->m_projectData.value(project).projectInfo;
@@ -1424,8 +1421,7 @@ void CppModelManager::recalculateProjectPartMappings()
     d->m_symbolFinder.clearCache();
 }
 
-void CppModelManagerPrivate::setupWatcher(const QFuture<void> &future,
-                                          ProjectExplorer::Project *project,
+void CppModelManagerPrivate::setupWatcher(const QFuture<void> &future, Project *project,
                                           ProjectData *projectData, CppModelManager *q)
 {
     projectData->indexer = new QFutureWatcher<void>(q);
@@ -1446,10 +1442,10 @@ void CppModelManagerPrivate::setupWatcher(const QFuture<void> &future,
 void CppModelManager::updateCppEditorDocuments(bool projectsUpdated) const
 {
     // Refresh visible documents
-    QSet<Core::IDocument *> visibleCppEditorDocuments;
-    const QList<Core::IEditor *> editors = Core::EditorManager::visibleEditors();
-    for (Core::IEditor *editor: editors) {
-        if (Core::IDocument *document = editor->document()) {
+    QSet<IDocument *> visibleCppEditorDocuments;
+    const QList<IEditor *> editors = EditorManager::visibleEditors();
+    for (IEditor *editor: editors) {
+        if (IDocument *document = editor->document()) {
             const FilePath filePath = document->filePath();
             if (CppEditorDocumentHandle *theCppEditorDocument = cppEditorDocument(filePath)) {
                 visibleCppEditorDocuments.insert(document);
@@ -1459,10 +1455,10 @@ void CppModelManager::updateCppEditorDocuments(bool projectsUpdated) const
     }
 
     // Mark invisible documents dirty
-    QSet<Core::IDocument *> invisibleCppEditorDocuments
-        = Utils::toSet(Core::DocumentModel::openedDocuments());
+    QSet<IDocument *> invisibleCppEditorDocuments
+        = Utils::toSet(DocumentModel::openedDocuments());
     invisibleCppEditorDocuments.subtract(visibleCppEditorDocuments);
-    for (Core::IDocument *document : std::as_const(invisibleCppEditorDocuments)) {
+    for (IDocument *document : std::as_const(invisibleCppEditorDocuments)) {
         const FilePath filePath = document->filePath();
         if (CppEditorDocumentHandle *theCppEditorDocument = cppEditorDocument(filePath)) {
             const CppEditorDocumentHandle::RefreshReason refreshReason = projectsUpdated
@@ -1483,7 +1479,7 @@ QFuture<void> CppModelManager::updateProjectInfo(const ProjectInfo::ConstPtr &ne
     QStringList removedProjectParts;
     bool filesRemoved = false;
 
-    ProjectExplorer::Project * const project = projectForProjectInfo(*newProjectInfo);
+    Project * const project = projectForProjectInfo(*newProjectInfo);
     if (!project)
         return {};
 
@@ -1589,20 +1585,20 @@ ProjectPart::ConstPtr CppModelManager::projectPartForId(const QString &projectPa
     return d->m_projectPartIdToProjectProjectPart.value(projectPartId);
 }
 
-QList<ProjectPart::ConstPtr> CppModelManager::projectPart(const Utils::FilePath &fileName) const
+QList<ProjectPart::ConstPtr> CppModelManager::projectPart(const FilePath &fileName) const
 {
     QReadLocker locker(&d->m_projectLock);
     return d->m_fileToProjectParts.value(fileName.canonicalPath());
 }
 
 QList<ProjectPart::ConstPtr> CppModelManager::projectPartFromDependencies(
-        const Utils::FilePath &fileName) const
+        const FilePath &fileName) const
 {
     QSet<ProjectPart::ConstPtr> parts;
-    const Utils::FilePaths deps = snapshot().filesDependingOn(fileName);
+    const FilePaths deps = snapshot().filesDependingOn(fileName);
 
     QReadLocker locker(&d->m_projectLock);
-    for (const Utils::FilePath &dep : deps)
+    for (const FilePath &dep : deps)
         parts.unite(Utils::toSet(d->m_fileToProjectParts.value(dep.canonicalPath())));
 
     return parts.values();
@@ -1614,7 +1610,7 @@ ProjectPart::ConstPtr CppModelManager::fallbackProjectPart()
     return d->m_fallbackProjectPart;
 }
 
-bool CppModelManager::isCppEditor(Core::IEditor *editor)
+bool CppModelManager::isCppEditor(IEditor *editor)
 {
     return editor->context().contains(ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 }
@@ -1647,7 +1643,7 @@ void CppModelManager::emitAbstractEditorSupportRemoved(const QString &filePath)
     emit abstractEditorSupportRemoved(filePath);
 }
 
-void CppModelManager::onProjectAdded(ProjectExplorer::Project *)
+void CppModelManager::onProjectAdded(Project *)
 {
     QWriteLocker locker(&d->m_projectLock);
     d->m_dirty = true;
@@ -1667,7 +1663,7 @@ static QStringList removedProjectParts(const QStringList &before, const QStringL
     return Utils::toList(b);
 }
 
-void CppModelManager::onAboutToRemoveProject(ProjectExplorer::Project *project)
+void CppModelManager::onAboutToRemoveProject(Project *project)
 {
     QStringList idsOfRemovedProjectParts;
 
@@ -1689,7 +1685,7 @@ void CppModelManager::onAboutToRemoveProject(ProjectExplorer::Project *project)
     delayedGC();
 }
 
-void CppModelManager::onActiveProjectChanged(ProjectExplorer::Project *project)
+void CppModelManager::onActiveProjectChanged(Project *project)
 {
     if (!project)
         return; // Last project closed.
@@ -1711,7 +1707,7 @@ void CppModelManager::onSourceFilesRefreshed() const
     }
 }
 
-void CppModelManager::onCurrentEditorChanged(Core::IEditor *editor)
+void CppModelManager::onCurrentEditorChanged(IEditor *editor)
 {
     if (!editor || !editor->document())
         return;
@@ -1752,7 +1748,7 @@ QSet<QString> CppModelManager::dependingInternalTargets(const FilePath &file) co
     return result;
 }
 
-QSet<QString> CppModelManager::internalTargets(const Utils::FilePath &filePath) const
+QSet<QString> CppModelManager::internalTargets(const FilePath &filePath) const
 {
     const QList<ProjectPart::ConstPtr> projectParts = projectPart(filePath);
     // if we have no project parts it's most likely a header with declarations only and CMake based
@@ -1761,14 +1757,13 @@ QSet<QString> CppModelManager::internalTargets(const Utils::FilePath &filePath)
     QSet<QString> targets;
     for (const ProjectPart::ConstPtr &part : projectParts) {
         targets.insert(part->buildSystemTarget);
-        if (part->buildTargetType != ProjectExplorer::BuildTargetType::Executable)
+        if (part->buildTargetType != BuildTargetType::Executable)
             targets.unite(dependingInternalTargets(filePath));
     }
     return targets;
 }
 
-void CppModelManager::renameIncludes(const Utils::FilePath &oldFilePath,
-                                     const Utils::FilePath &newFilePath)
+void CppModelManager::renameIncludes(const FilePath &oldFilePath, const FilePath &newFilePath)
 {
     if (oldFilePath.isEmpty() || newFilePath.isEmpty())
         return;
@@ -1815,7 +1810,7 @@ void CppModelManager::renameIncludes(const Utils::FilePath &oldFilePath,
         const QTextBlock &block = file->document()->findBlockByNumber(loc.second - 1);
         const int replaceStart = block.text().indexOf(oldFileName);
         if (replaceStart > -1) {
-            Utils::ChangeSet changeSet;
+            ChangeSet changeSet;
             changeSet.replace(block.position() + replaceStart,
                               block.position() + replaceStart + oldFileName.length(),
                               newFileName);
@@ -1843,13 +1838,13 @@ static const char *belongingClassName(const Function *function)
     return nullptr;
 }
 
-QSet<QString> CppModelManager::symbolsInFiles(const QSet<Utils::FilePath> &files) const
+QSet<QString> CppModelManager::symbolsInFiles(const QSet<FilePath> &files) const
 {
     QSet<QString> uniqueSymbols;
     const Snapshot cppSnapShot = snapshot();
 
     // Iterate over the files and get interesting symbols
-    for (const Utils::FilePath &file : files) {
+    for (const FilePath &file : files) {
         // Add symbols from the C++ code model
         const CPlusPlus::Document::Ptr doc = cppSnapShot.document(file);
         if (!doc.isNull() && doc->control()) {
@@ -1881,7 +1876,7 @@ QSet<QString> CppModelManager::symbolsInFiles(const QSet<Utils::FilePath> &files
 
 void CppModelManager::onCoreAboutToClose()
 {
-    Core::ProgressManager::cancelTasks(Constants::TASK_INDEX);
+    ProgressManager::cancelTasks(Constants::TASK_INDEX);
     d->m_enableGC = false;
 }
 
@@ -1891,27 +1886,27 @@ void CppModelManager::setupFallbackProjectPart()
     RawProjectPart rpp;
     rpp.setMacros(definedMacros());
     rpp.setHeaderPaths(headerPaths());
-    rpp.setQtVersion(Utils::QtMajorVersion::Qt5);
+    rpp.setQtVersion(QtMajorVersion::Qt5);
 
     // Do not activate ObjectiveCExtensions since this will lead to the
     // "objective-c++" language option for a project-less *.cpp file.
-    Utils::LanguageExtensions langExtensions = Utils::LanguageExtension::All;
-    langExtensions &= ~Utils::LanguageExtensions(Utils::LanguageExtension::ObjectiveC);
+    LanguageExtensions langExtensions = LanguageExtension::All;
+    langExtensions &= ~LanguageExtensions(LanguageExtension::ObjectiveC);
 
     // TODO: Use different fallback toolchain for different kinds of files?
     const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr;
     const ToolChain * const defaultTc = defaultKit
             ? ToolChainKitAspect::cxxToolChain(defaultKit) : nullptr;
     if (defaultKit && defaultTc) {
-        Utils::FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
+        FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
         if (sysroot.isEmpty())
-            sysroot = Utils::FilePath::fromString(defaultTc->sysRoot());
+            sysroot = FilePath::fromString(defaultTc->sysRoot());
         Utils::Environment env = defaultKit->buildEnvironment();
         tcInfo = ToolChainInfo(defaultTc, sysroot, env);
         const auto macroInspectionWrapper = [runner = tcInfo.macroInspectionRunner](
                 const QStringList &flags) {
             ToolChain::MacroInspectionReport report = runner(flags);
-            report.languageVersion = Utils::LanguageVersion::LatestCxx;
+            report.languageVersion = LanguageVersion::LatestCxx;
             return report;
         };
         tcInfo.macroInspectionRunner = macroInspectionWrapper;
@@ -1941,7 +1936,7 @@ void CppModelManager::GC()
         filesInEditorSupports << abstractEditorSupport->filePath();
 
     Snapshot currentSnapshot = snapshot();
-    QSet<Utils::FilePath> reachableFiles;
+    QSet<FilePath> reachableFiles;
     // The configuration file is part of the project files, which is just fine.
     // If single files are open, without any project, then there is no need to
     // keep the configuration file around.
@@ -1964,7 +1959,7 @@ void CppModelManager::GC()
     QStringList notReachableFiles;
     Snapshot newSnapshot;
     for (Snapshot::const_iterator it = currentSnapshot.begin(); it != currentSnapshot.end(); ++it) {
-        const Utils::FilePath &fileName = it.key();
+        const FilePath &fileName = it.key();
 
         if (reachableFiles.contains(fileName))
             newSnapshot.insert(it.value());
@@ -2001,7 +1996,7 @@ TextEditor::BaseHoverHandler *CppModelManager::createHoverHandler() const
 }
 
 void CppModelManager::followSymbol(const CursorInEditor &data,
-                                   const Utils::LinkHandler &processLinkCallback,
+                                   const LinkHandler &processLinkCallback,
                                    bool resolveTarget, bool inNextSplit, Backend backend)
 {
     instance()->modelManagerSupport(backend)->followSymbol(data, processLinkCallback,
@@ -2009,7 +2004,7 @@ void CppModelManager::followSymbol(const CursorInEditor &data,
 }
 
 void CppModelManager::followSymbolToType(const CursorInEditor &data,
-                                         const Utils::LinkHandler &processLinkCallback,
+                                         const LinkHandler &processLinkCallback,
                                          bool inNextSplit, Backend backend)
 {
     instance()->modelManagerSupport(backend)->followSymbolToType(data, processLinkCallback,
@@ -2017,13 +2012,13 @@ void CppModelManager::followSymbolToType(const CursorInEditor &data,
 }
 
 void CppModelManager::switchDeclDef(const CursorInEditor &data,
-                                    const Utils::LinkHandler &processLinkCallback,
+                                    const LinkHandler &processLinkCallback,
                                     Backend backend)
 {
     instance()->modelManagerSupport(backend)->switchDeclDef(data, processLinkCallback);
 }
 
-Core::ILocatorFilter *CppModelManager::createAuxiliaryCurrentDocumentFilter()
+ILocatorFilter *CppModelManager::createAuxiliaryCurrentDocumentFilter()
 {
     const auto filter = new Internal::CppCurrentDocumentFilter(instance());
     filter->makeAuxiliary();
@@ -2049,7 +2044,7 @@ FilePaths CppModelManager::projectFiles()
     return d->m_projectFiles;
 }
 
-ProjectExplorer::HeaderPaths CppModelManager::headerPaths()
+HeaderPaths CppModelManager::headerPaths()
 {
     QWriteLocker locker(&d->m_projectLock);
     ensureUpdated();
@@ -2057,13 +2052,13 @@ ProjectExplorer::HeaderPaths CppModelManager::headerPaths()
     return d->m_headerPaths;
 }
 
-void CppModelManager::setHeaderPaths(const ProjectExplorer::HeaderPaths &headerPaths)
+void CppModelManager::setHeaderPaths(const HeaderPaths &headerPaths)
 {
     QWriteLocker locker(&d->m_projectLock);
     d->m_headerPaths = headerPaths;
 }
 
-ProjectExplorer::Macros CppModelManager::definedMacros()
+Macros CppModelManager::definedMacros()
 {
     QWriteLocker locker(&d->m_projectLock);
     ensureUpdated();
diff --git a/src/plugins/languageclient/locatorfilter.cpp b/src/plugins/languageclient/locatorfilter.cpp
index 2c933c12204..2b0eca3a578 100644
--- a/src/plugins/languageclient/locatorfilter.cpp
+++ b/src/plugins/languageclient/locatorfilter.cpp
@@ -23,6 +23,7 @@
 #include <QFutureWatcher>
 #include <QRegularExpression>
 
+using namespace Core;
 using namespace LanguageServerProtocol;
 
 namespace LanguageClient {
@@ -36,7 +37,7 @@ DocumentLocatorFilter::DocumentLocatorFilter()
     setDefaultShortcutString(".");
     setDefaultIncludedByDefault(false);
     setPriority(ILocatorFilter::Low);
-    connect(Core::EditorManager::instance(), &Core::EditorManager::currentEditorChanged,
+    connect(EditorManager::instance(), &EditorManager::currentEditorChanged,
             this, &DocumentLocatorFilter::updateCurrentClient);
 }
 
@@ -56,7 +57,7 @@ void DocumentLocatorFilter::updateCurrentClient()
             m_updateSymbolsConnection = connect(m_symbolCache, &DocumentSymbolCache::gotSymbols,
                                                 this, &DocumentLocatorFilter::updateSymbols);
         }
-        m_resetSymbolsConnection = connect(document, &Core::IDocument::contentsChanged,
+        m_resetSymbolsConnection = connect(document, &IDocument::contentsChanged,
                                            this, &DocumentLocatorFilter::resetSymbols);
         m_currentUri = client->hostPathToServerUri(document->filePath());
         m_pathMapper = client->hostPathMapper();
@@ -85,11 +86,11 @@ void DocumentLocatorFilter::resetSymbols()
     m_currentSymbols.reset();
 }
 
-static Core::LocatorFilterEntry generateLocatorEntry(const SymbolInformation &info,
-                                                     Core::ILocatorFilter *filter,
-                                                     DocumentUri::PathMapper pathMapper)
+static LocatorFilterEntry generateLocatorEntry(const SymbolInformation &info,
+                                               ILocatorFilter *filter,
+                                               DocumentUri::PathMapper pathMapper)
 {
-    Core::LocatorFilterEntry entry;
+    LocatorFilterEntry entry;
     entry.filter = filter;
     entry.displayName = info.name();
     if (std::optional<QString> container = info.containerName())
@@ -99,15 +100,15 @@ static Core::LocatorFilterEntry generateLocatorEntry(const SymbolInformation &in
     return entry;
 }
 
-Core::LocatorFilterEntry DocumentLocatorFilter::generateLocatorEntry(const SymbolInformation &info)
+LocatorFilterEntry DocumentLocatorFilter::generateLocatorEntry(const SymbolInformation &info)
 {
     QTC_ASSERT(m_pathMapper, return {});
     return LanguageClient::generateLocatorEntry(info, this, m_pathMapper);
 }
 
-QList<Core::LocatorFilterEntry> DocumentLocatorFilter::generateLocatorEntries(
+QList<LocatorFilterEntry> DocumentLocatorFilter::generateLocatorEntries(
         const SymbolInformation &info, const QRegularExpression &regexp,
-        const Core::LocatorFilterEntry &parent)
+        const LocatorFilterEntry &parent)
 {
     Q_UNUSED(parent)
     if (regexp.match(info.name()).hasMatch())
@@ -115,12 +116,11 @@ QList<Core::LocatorFilterEntry> DocumentLocatorFilter::generateLocatorEntries(
     return {};
 }
 
-Core::LocatorFilterEntry DocumentLocatorFilter::generateLocatorEntry(
-        const DocumentSymbol &info,
-        const Core::LocatorFilterEntry &parent)
+LocatorFilterEntry DocumentLocatorFilter::generateLocatorEntry(const DocumentSymbol &info,
+                                                               const LocatorFilterEntry &parent)
 {
     Q_UNUSED(parent)
-    Core::LocatorFilterEntry entry;
+    LocatorFilterEntry entry;
     entry.filter = this;
     entry.displayName = info.name();
     if (std::optional<QString> detail = info.detail())
@@ -131,14 +131,14 @@ Core::LocatorFilterEntry DocumentLocatorFilter::generateLocatorEntry(
     return entry;
 }
 
-QList<Core::LocatorFilterEntry> DocumentLocatorFilter::generateLocatorEntries(
+QList<LocatorFilterEntry> DocumentLocatorFilter::generateLocatorEntries(
         const DocumentSymbol &info, const QRegularExpression &regexp,
-        const Core::LocatorFilterEntry &parent)
+        const LocatorFilterEntry &parent)
 {
-    QList<Core::LocatorFilterEntry> entries;
+    QList<LocatorFilterEntry> entries;
     const QList<DocumentSymbol> children = info.children().value_or(QList<DocumentSymbol>());
     const bool hasMatch = regexp.match(info.name()).hasMatch();
-    Core::LocatorFilterEntry entry;
+    LocatorFilterEntry entry;
     if (hasMatch || !children.isEmpty())
         entry = generateLocatorEntry(info, parent);
     if (hasMatch)
@@ -149,10 +149,10 @@ QList<Core::LocatorFilterEntry> DocumentLocatorFilter::generateLocatorEntries(
 }
 
 template<class T>
-QList<Core::LocatorFilterEntry> DocumentLocatorFilter::generateEntries(const QList<T> &list,
+QList<LocatorFilterEntry> DocumentLocatorFilter::generateEntries(const QList<T> &list,
                                                                        const QString &filter)
 {
-    QList<Core::LocatorFilterEntry> entries;
+    QList<LocatorFilterEntry> entries;
     FuzzyMatcher::CaseSensitivity caseSensitivity
         = ILocatorFilter::caseSensitivity(filter) == Qt::CaseSensitive
               ? FuzzyMatcher::CaseSensitivity::CaseSensitive
@@ -175,20 +175,17 @@ void DocumentLocatorFilter::prepareSearch(const QString &/*entry*/)
     }
 }
 
-QList<Core::LocatorFilterEntry> DocumentLocatorFilter::matchesFor(
-    QFutureInterface<Core::LocatorFilterEntry> &future, const QString &entry)
+QList<LocatorFilterEntry> DocumentLocatorFilter::matchesFor(
+    QFutureInterface<LocatorFilterEntry> &future, const QString &entry)
 {
     QMutexLocker locker(&m_mutex);
     if (!m_symbolCache)
         return {};
     if (!m_currentSymbols.has_value()) {
         QEventLoop loop;
-        connect(this, &DocumentLocatorFilter::symbolsUpToDate, &loop, [&]() { loop.exit(1); });
-        QFutureWatcher<Core::LocatorFilterEntry> watcher;
-        connect(&watcher,
-                &QFutureWatcher<Core::LocatorFilterEntry>::canceled,
-                &loop,
-                &QEventLoop::quit);
+        connect(this, &DocumentLocatorFilter::symbolsUpToDate, &loop, [&] { loop.exit(1); });
+        QFutureWatcher<LocatorFilterEntry> watcher;
+        connect(&watcher, &QFutureWatcher<LocatorFilterEntry>::canceled, &loop, &QEventLoop::quit);
         watcher.setFuture(future.future());
         locker.unlock();
         if (!loop.exec())
@@ -206,7 +203,7 @@ QList<Core::LocatorFilterEntry> DocumentLocatorFilter::matchesFor(
     return {};
 }
 
-void DocumentLocatorFilter::accept(const Core::LocatorFilterEntry &selection,
+void DocumentLocatorFilter::accept(const LocatorFilterEntry &selection,
                                    QString * /*newText*/,
                                    int * /*selectionStart*/,
                                    int * /*selectionLength*/) const
@@ -217,11 +214,10 @@ void DocumentLocatorFilter::accept(const Core::LocatorFilterEntry &selection,
         const Utils::Link link(m_currentUri.toFilePath(m_pathMapper),
                                lineColumn.line + 1,
                                lineColumn.column);
-        Core::EditorManager::openEditorAt(link, {}, Core::EditorManager::AllowExternalEditor);
+        EditorManager::openEditorAt(link, {}, EditorManager::AllowExternalEditor);
     } else if (selection.internalData.canConvert<Utils::Link>()) {
-        Core::EditorManager::openEditorAt(qvariant_cast<Utils::Link>(selection.internalData),
-                                          {},
-                                          Core::EditorManager::AllowExternalEditor);
+        EditorManager::openEditorAt(qvariant_cast<Utils::Link>(selection.internalData), {},
+                                    EditorManager::AllowExternalEditor);
     }
 }
 
@@ -283,16 +279,16 @@ void WorkspaceLocatorFilter::prepareSearch(const QString &entry,
     }
 }
 
-QList<Core::LocatorFilterEntry> WorkspaceLocatorFilter::matchesFor(
-    QFutureInterface<Core::LocatorFilterEntry> &future, const QString & /*entry*/)
+QList<LocatorFilterEntry> WorkspaceLocatorFilter::matchesFor(
+    QFutureInterface<LocatorFilterEntry> &future, const QString & /*entry*/)
 {
     QMutexLocker locker(&m_mutex);
     if (!m_pendingRequests.isEmpty()) {
         QEventLoop loop;
-        connect(this, &WorkspaceLocatorFilter::allRequestsFinished, &loop, [&]() { loop.exit(1); });
-        QFutureWatcher<Core::LocatorFilterEntry> watcher;
+        connect(this, &WorkspaceLocatorFilter::allRequestsFinished, &loop, [&] { loop.exit(1); });
+        QFutureWatcher<LocatorFilterEntry> watcher;
         connect(&watcher,
-                &QFutureWatcher<Core::LocatorFilterEntry>::canceled,
+                &QFutureWatcher<LocatorFilterEntry>::canceled,
                 &loop,
                 &QEventLoop::quit);
         watcher.setFuture(future.future());
@@ -315,15 +311,15 @@ QList<Core::LocatorFilterEntry> WorkspaceLocatorFilter::matchesFor(
     return Utils::transform(m_results, generateEntry).toList();
 }
 
-void WorkspaceLocatorFilter::accept(const Core::LocatorFilterEntry &selection,
+void WorkspaceLocatorFilter::accept(const LocatorFilterEntry &selection,
                                     QString * /*newText*/,
                                     int * /*selectionStart*/,
                                     int * /*selectionLength*/) const
 {
-    if (selection.internalData.canConvert<Utils::Link>())
-        Core::EditorManager::openEditorAt(qvariant_cast<Utils::Link>(selection.internalData),
-                                          {},
-                                          Core::EditorManager::AllowExternalEditor);
+    if (selection.internalData.canConvert<Utils::Link>()) {
+        EditorManager::openEditorAt(qvariant_cast<Utils::Link>(selection.internalData), {},
+                                    EditorManager::AllowExternalEditor);
+    }
 }
 
 void WorkspaceLocatorFilter::handleResponse(Client *client,
diff --git a/src/plugins/modeleditor/elementtasks.cpp b/src/plugins/modeleditor/elementtasks.cpp
index e0efd6914a6..6702344db5c 100644
--- a/src/plugins/modeleditor/elementtasks.cpp
+++ b/src/plugins/modeleditor/elementtasks.cpp
@@ -33,6 +33,8 @@
 
 #include <QMenu>
 
+using namespace Core;
+
 namespace ModelEditor {
 namespace Internal {
 
@@ -87,15 +89,14 @@ bool ElementTasks::hasClassDefinition(const qmt::MElement *element) const
                 ? klass->name()
                 : klass->umlNamespace() + "::" + klass->name();
 
-        Core::ILocatorFilter *classesFilter
-                = CppEditor::CppModelManager::instance()->classesFilter();
+        ILocatorFilter *classesFilter = CppEditor::CppModelManager::instance()->classesFilter();
         if (!classesFilter)
             return false;
 
-        QFutureInterface<Core::LocatorFilterEntry> dummyInterface;
-        const QList<Core::LocatorFilterEntry> matches
+        QFutureInterface<LocatorFilterEntry> dummyInterface;
+        const QList<LocatorFilterEntry> matches
             = classesFilter->matchesFor(dummyInterface, qualifiedClassName);
-        for (const Core::LocatorFilterEntry &entry : matches) {
+        for (const LocatorFilterEntry &entry : matches) {
             CppEditor::IndexItem::Ptr info = qvariant_cast<CppEditor::IndexItem::Ptr>(entry.internalData);
             if (info->scopedSymbolName() != qualifiedClassName)
                 continue;
@@ -124,19 +125,18 @@ void ElementTasks::openClassDefinition(const qmt::MElement *element)
                 ? klass->name()
                 : klass->umlNamespace() + "::" + klass->name();
 
-        Core::ILocatorFilter *classesFilter
-                = CppEditor::CppModelManager::instance()->classesFilter();
+        ILocatorFilter *classesFilter = CppEditor::CppModelManager::instance()->classesFilter();
         if (!classesFilter)
             return;
 
-        QFutureInterface<Core::LocatorFilterEntry> dummyInterface;
-        const QList<Core::LocatorFilterEntry> matches
+        QFutureInterface<LocatorFilterEntry> dummyInterface;
+        const QList<LocatorFilterEntry> matches
             = classesFilter->matchesFor(dummyInterface, qualifiedClassName);
-        for (const Core::LocatorFilterEntry &entry : matches) {
+        for (const LocatorFilterEntry &entry : matches) {
             CppEditor::IndexItem::Ptr info = qvariant_cast<CppEditor::IndexItem::Ptr>(entry.internalData);
             if (info->scopedSymbolName() != qualifiedClassName)
                 continue;
-            if (Core::EditorManager::instance()->openEditorAt(
+            if (EditorManager::instance()->openEditorAt(
                     {info->filePath(), info->line(), info->column()})) {
                 return;
             }
diff --git a/src/plugins/qmljstools/qmljsfunctionfilter.cpp b/src/plugins/qmljstools/qmljsfunctionfilter.cpp
index 4d4ce05fb72..7ce42af1149 100644
--- a/src/plugins/qmljstools/qmljsfunctionfilter.cpp
+++ b/src/plugins/qmljstools/qmljsfunctionfilter.cpp
@@ -12,12 +12,13 @@
 
 #include <numeric>
 
+using namespace Core;
 using namespace QmlJSTools::Internal;
 
 Q_DECLARE_METATYPE(LocatorData::Entry)
 
 FunctionFilter::FunctionFilter(LocatorData *data, QObject *parent)
-    : Core::ILocatorFilter(parent)
+    : ILocatorFilter(parent)
     , m_data(data)
 {
     setId("Functions");
@@ -28,11 +29,10 @@ FunctionFilter::FunctionFilter(LocatorData *data, QObject *parent)
 
 FunctionFilter::~FunctionFilter() = default;
 
-QList<Core::LocatorFilterEntry> FunctionFilter::matchesFor(
-        QFutureInterface<Core::LocatorFilterEntry> &future,
-        const QString &entry)
+QList<LocatorFilterEntry> FunctionFilter::matchesFor(QFutureInterface<LocatorFilterEntry> &future,
+                                                     const QString &entry)
 {
-    QList<Core::LocatorFilterEntry> entries[int(MatchLevel::Count)];
+    QList<LocatorFilterEntry> entries[int(MatchLevel::Count)];
     const Qt::CaseSensitivity caseSensitivityForPrefix = caseSensitivity(entry);
 
     const QRegularExpression regexp = createRegExp(entry);
@@ -51,7 +51,7 @@ QList<Core::LocatorFilterEntry> FunctionFilter::matchesFor(
             const QRegularExpressionMatch match = regexp.match(info.symbolName);
             if (match.hasMatch()) {
                 QVariant id = QVariant::fromValue(info);
-                Core::LocatorFilterEntry filterEntry(this, info.displayName, id/*, info.icon*/);
+                LocatorFilterEntry filterEntry(this, info.displayName, id/*, info.icon*/);
                 filterEntry.extraInfo = info.extraInfo;
                 filterEntry.highlightInfo = highlightInfo(match);
 
@@ -67,18 +67,17 @@ QList<Core::LocatorFilterEntry> FunctionFilter::matchesFor(
 
     for (auto &entry : entries) {
         if (entry.size() < 1000)
-            Utils::sort(entry, Core::LocatorFilterEntry::compareLexigraphically);
+            Utils::sort(entry, LocatorFilterEntry::compareLexigraphically);
     }
-
-    return std::accumulate(std::begin(entries), std::end(entries), QList<Core::LocatorFilterEntry>());
+    return std::accumulate(std::begin(entries), std::end(entries), QList<LocatorFilterEntry>());
 }
 
-void FunctionFilter::accept(const Core::LocatorFilterEntry &selection,
+void FunctionFilter::accept(const LocatorFilterEntry &selection,
                             QString *newText, int *selectionStart, int *selectionLength) const
 {
     Q_UNUSED(newText)
     Q_UNUSED(selectionStart)
     Q_UNUSED(selectionLength)
     const LocatorData::Entry entry = qvariant_cast<LocatorData::Entry>(selection.internalData);
-    Core::EditorManager::openEditorAt({entry.fileName, entry.line, entry.column});
+    EditorManager::openEditorAt({entry.fileName, entry.line, entry.column});
 }