1 files changed, 44 insertions, 39 deletions

diff --git a/src/plugins/qmljstools/qmljsfunctionfilter.cpp b/src/plugins/qmljstools/qmljsfunctionfilter.cpp
index 4d4ce05fb72..34a60040f3c 100644
--- a/src/plugins/qmljstools/qmljsfunctionfilter.cpp
+++ b/src/plugins/qmljstools/qmljsfunctionfilter.cpp
@@ -5,80 +5,85 @@
 #include "qmljslocatordata.h"
 #include "qmljstoolstr.h"
 
-#include <coreplugin/editormanager/editormanager.h>
+#include <extensionsystem/pluginmanager.h>
+
 #include <utils/algorithm.h>
+#include <utils/async.h>
 
 #include <QRegularExpression>
 
-#include <numeric>
-
+using namespace Core;
 using namespace QmlJSTools::Internal;
+using namespace Utils;
 
 Q_DECLARE_METATYPE(LocatorData::Entry)
 
-FunctionFilter::FunctionFilter(LocatorData *data, QObject *parent)
-    : Core::ILocatorFilter(parent)
-    , m_data(data)
+QmlJSFunctionsFilter::QmlJSFunctionsFilter(LocatorData *data)
+    : m_data(data)
 {
     setId("Functions");
     setDisplayName(Tr::tr("QML Functions"));
+    setDescription(Tr::tr("Locates QML functions in any open project."));
     setDefaultShortcutString("m");
-    setDefaultIncludedByDefault(false);
 }
 
-FunctionFilter::~FunctionFilter() = default;
-
-QList<Core::LocatorFilterEntry> FunctionFilter::matchesFor(
-        QFutureInterface<Core::LocatorFilterEntry> &future,
-        const QString &entry)
+static void matches(QPromise<void> &promise, const LocatorStorage &storage,
+                    const QHash<FilePath, QList<LocatorData::Entry>> &locatorEntries)
 {
-    QList<Core::LocatorFilterEntry> entries[int(MatchLevel::Count)];
-    const Qt::CaseSensitivity caseSensitivityForPrefix = caseSensitivity(entry);
-
-    const QRegularExpression regexp = createRegExp(entry);
+    const QString input = storage.input();
+    const Qt::CaseSensitivity caseSensitivityForPrefix = ILocatorFilter::caseSensitivity(input);
+    const QRegularExpression regexp = ILocatorFilter::createRegExp(input);
     if (!regexp.isValid())
-        return {};
+        return;
 
-    const QHash<Utils::FilePath, QList<LocatorData::Entry>> locatorEntries = m_data->entries();
+    LocatorFilterEntries entries[int(ILocatorFilter::MatchLevel::Count)];
     for (const QList<LocatorData::Entry> &items : locatorEntries) {
-        if (future.isCanceled())
-            break;
-
         for (const LocatorData::Entry &info : items) {
+            if (promise.isCanceled())
+                return;
+
             if (info.type != LocatorData::Function)
                 continue;
 
             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;
+                filterEntry.displayName = info.displayName;
+                filterEntry.linkForEditor = {info.fileName, info.line, info.column};
                 filterEntry.extraInfo = info.extraInfo;
-                filterEntry.highlightInfo = highlightInfo(match);
+                filterEntry.highlightInfo = ILocatorFilter::highlightInfo(match);
 
-                if (filterEntry.displayName.startsWith(entry, caseSensitivityForPrefix))
-                    entries[int(MatchLevel::Best)].append(filterEntry);
-                else if (filterEntry.displayName.contains(entry, caseSensitivityForPrefix))
-                    entries[int(MatchLevel::Better)].append(filterEntry);
+                if (filterEntry.displayName.startsWith(input, caseSensitivityForPrefix))
+                    entries[int(ILocatorFilter::MatchLevel::Best)].append(filterEntry);
+                else if (filterEntry.displayName.contains(input, caseSensitivityForPrefix))
+                    entries[int(ILocatorFilter::MatchLevel::Better)].append(filterEntry);
                 else
-                    entries[int(MatchLevel::Good)].append(filterEntry);
+                    entries[int(ILocatorFilter::MatchLevel::Good)].append(filterEntry);
             }
         }
     }
 
     for (auto &entry : entries) {
+        if (promise.isCanceled())
+            return;
+
         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>());
+    storage.reportOutput(std::accumulate(std::begin(entries), std::end(entries),
+                                         LocatorFilterEntries()));
 }
 
-void FunctionFilter::accept(const Core::LocatorFilterEntry &selection,
-                            QString *newText, int *selectionStart, int *selectionLength) const
+LocatorMatcherTasks QmlJSFunctionsFilter::matchers()
 {
-    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});
+    using namespace Tasking;
+
+    TreeStorage<LocatorStorage> storage;
+
+    const auto onSetup = [storage, entries = m_data->entries()](Async<void> &async) {
+        async.setFutureSynchronizer(ExtensionSystem::PluginManager::futureSynchronizer());
+        async.setConcurrentCallData(matches, *storage, entries);
+    };
+
+    return {{AsyncTask<void>(onSetup), storage}};
 }