qmlls: remove unused indexing code

It seems that we have some code in qmlls that runs an "indexing" thread
in the background to load non-opened files. It is not tested and never
used : the only commit using the indexing functionality is
2717985 but never sets `m_status` to
`Index`, so that the indexing is almost never run.

There are some code paths, for example when a
DidChangeWorkspaceFoldersNotification is received by the server, where
the indexing is triggered despite it being disabled.

Enabling the indexing leads to a ASAN crash, probably because of some
missing synchronization on some shared data like:
* QQmlJSImporter and QQmlJSResourceFileMapper: both needed to construct
  the Dom while loading a QML file,
* QQmlJScope::Ptr: the same ptr might be lazyloaded by two different
  threads at the same time)

Remove the indexing funtionality from the code, and pick the change
back to avoid memory errors on DidChangeWorkspaceFoldersNotifications.

This could be related to one of the qmlls crashes described in the
comments of QTBUG-133586.

Task-number: QTBUG-133586
Pick-to: 6.8 6.9 6.10
Change-Id: I547cf11150dc25b04208a83bf5e123e7ee5b0482
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

Author: samishalayel

src/qmlls/qqmlcodemodel.cpp

@@ -69,21 +69,20 @@ synchronization here.
 \section2 Parallelism/Theading
 Most operations are not parallel and usually take place in the main thread (but are still thread
 safe).
-There are two main task that are executed in parallel: Indexing, and OpenDocumentUpdate.
-Indexing is meant to keep the global view up to date.
+There is one task that is executed in parallel: OpenDocumentUpdate.
 OpenDocumentUpdate keeps the snapshots of the open documents up to date.
 
 There is always a tension between being responsive, using all threads available, and avoid to hog
 too many resources. One can choose different parallelization strategies, we went with a flexiable
 approach.
-We have (private) functions that execute part of the work: indexSome() and openUpdateSome(). These
+We have (private) functions that execute part of the work: openUpdateSome(). These
 do all locking needed, get some work, do it without locks, and at the end update the state of the
 code model. If there is more work, then they return true. Thus while (xxxSome()); works until there
 is no work left.
 
-addDirectoriesToIndex(), the internal addDirectory() and addOpenToUpdate() add more work to do.
+The internal addOpenToUpdate() add more work to do.
 
-indexNeedsUpdate() and openNeedUpdate(), check if there is work to do, and if yes ensure that a
+openNeedUpdate() checks if there is work to do, and if yes ensure that a
 worker thread (or more) that work on it exist.
 */
 
@@ -119,7 +118,7 @@ QQmlCodeModel::~QQmlCodeModel()
             QMutexLocker l(&m_mutex);
             m_state = State::Stopping;
             m_openDocumentsToUpdate.clear();
-            shouldWait = m_nIndexInProgress != 0 || m_nUpdateInProgress != 0;
+            shouldWait = m_nUpdateInProgress != 0;
         }
         if (!shouldWait)
             break;
@@ -132,143 +131,8 @@ OpenDocumentSnapshot QQmlCodeModel::snapshotByUrl(const QByteArray &url)
     return openDocumentByUrl(url).snapshot;
 }
 
-int QQmlCodeModel::indexEvalProgress() const
-{
-    Q_ASSERT(!m_mutex.tryLock()); // should be called while locked
-    const int dirCost = 10;
-    int costToDo = 1;
-    for (const ToIndex &el : std::as_const(m_toIndex))
-        costToDo += dirCost * el.leftDepth;
-    costToDo += m_indexInProgressCost;
-    return m_indexDoneCost * 100 / (costToDo + m_indexDoneCost);
-}
-
-void QQmlCodeModel::indexStart()
-{
-    Q_ASSERT(!m_mutex.tryLock()); // should be called while locked
-    qCDebug(codeModelLog) << "indexStart";
-}
-
-void QQmlCodeModel::indexEnd()
-{
-    Q_ASSERT(!m_mutex.tryLock()); // should be called while locked
-    qCDebug(codeModelLog) << "indexEnd";
-    m_lastIndexProgress = 0;
-    m_nIndexInProgress = 0;
-    m_toIndex.clear();
-    m_indexInProgressCost = 0;
-    m_indexDoneCost = 0;
-}
-
-void QQmlCodeModel::indexSendProgress(int progress)
-{
-    if (progress <= m_lastIndexProgress)
-        return;
-    m_lastIndexProgress = progress;
-    // ### actually send progress
-}
-
-bool QQmlCodeModel::indexCancelled()
-{
-    QMutexLocker l(&m_mutex);
-    if (m_state == State::Stopping)
-        return true;
-    return false;
-}
-
-void QQmlCodeModel::indexDirectory(const QString &path, int depthLeft)
-{
-    if (indexCancelled())
-        return;
-    QDir dir(path);
-    if (depthLeft > 1) {
-        const QStringList dirs =
-                dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot | QDir::NoSymLinks);
-        for (const QString &child : dirs)
-            addDirectory(dir.filePath(child), --depthLeft);
-    }
-    const QStringList qmljs =
-            dir.entryList(QStringList({ u"*.qml"_s, u"*.js"_s, u"*.mjs"_s }), QDir::Files);
-    int progress = 0;
-    {
-        QMutexLocker l(&m_mutex);
-        m_indexInProgressCost += qmljs.size();
-        progress = indexEvalProgress();
-    }
-    indexSendProgress(progress);
-    if (qmljs.isEmpty())
-        return;
-    DomItem newCurrent = m_currentEnv.makeCopy(DomItem::CopyOption::EnvConnected).item();
-    for (const QString &file : qmljs) {
-        if (indexCancelled())
-            return;
-        QString fPath = dir.filePath(file);
-        auto newCurrentPtr = newCurrent.ownerAs<DomEnvironment>();
-        FileToLoad fileToLoad = FileToLoad::fromFileSystem(newCurrentPtr, fPath);
-        if (!fileToLoad.canonicalPath().isEmpty()) {
-            newCurrentPtr->loadBuiltins();
-            newCurrentPtr->loadFile(fileToLoad, [](Path, const DomItem &, const DomItem &) {});
-            newCurrentPtr->loadPendingDependencies();
-            newCurrent.commitToBase(m_validEnv.ownerAs<DomEnvironment>());
-        }
-        {
-            QMutexLocker l(&m_mutex);
-            ++m_indexDoneCost;
-            --m_indexInProgressCost;
-            progress = indexEvalProgress();
-        }
-        indexSendProgress(progress);
-    }
-}
-
-void QQmlCodeModel::addDirectoriesToIndex(const QStringList &paths, QLanguageServer *server)
-{
-    Q_UNUSED(server);
-    // ### create progress, &scan in a separate instance
-    const int maxDepth = 5;
-    for (const auto &path : paths)
-        addDirectory(path, maxDepth);
-    indexNeedsUpdate();
-}
-
-void QQmlCodeModel::addDirectory(const QString &path, int depthLeft)
-{
-    if (depthLeft < 1)
-        return;
-    {
-        QMutexLocker l(&m_mutex);
-        for (auto it = m_toIndex.begin(); it != m_toIndex.end();) {
-            if (it->path.startsWith(path)) {
-                if (it->path.size() == path.size())
-                    return;
-                if (it->path.at(path.size()) == u'/') {
-                    it = m_toIndex.erase(it);
-                    continue;
-                }
-            } else if (path.startsWith(it->path) && path.at(it->path.size()) == u'/')
-                return;
-            ++it;
-        }
-        m_toIndex.append({ path, depthLeft });
-    }
-}
-
 void QQmlCodeModel::removeDirectory(const QString &path)
 {
-    {
-        QMutexLocker l(&m_mutex);
-        auto toRemove = [path](const QString &p) {
-            return p.startsWith(path) && (p.size() == path.size() || p.at(path.size()) == u'/');
-        };
-        auto it = m_toIndex.begin();
-        auto end = m_toIndex.end();
-        while (it != end) {
-            if (toRemove(it->path))
-                it = m_toIndex.erase(it);
-            else
-                ++it;
-        }
-    }
     if (auto validEnvPtr = m_validEnv.ownerAs<DomEnvironment>())
         validEnvPtr->removePath(path);
     if (auto currentEnvPtr = m_currentEnv.ownerAs<DomEnvironment>())
@@ -332,59 +196,13 @@ const RegisteredSemanticTokens &QQmlCodeModel::registeredTokens() const
     return m_tokens;
 }
 
-void QQmlCodeModel::indexNeedsUpdate()
-{
-    const int maxIndexThreads = 1;
-    {
-        QMutexLocker l(&m_mutex);
-        if (m_toIndex.isEmpty() || m_nIndexInProgress >= maxIndexThreads)
-            return;
-        if (++m_nIndexInProgress == 1)
-            indexStart();
-    }
-    QThreadPool::globalInstance()->start([this]() {
-        while (indexSome()) { }
-    });
-}
-
-bool QQmlCodeModel::indexSome()
-{
-    qCDebug(codeModelLog) << "indexSome";
-    ToIndex toIndex;
-    {
-        QMutexLocker l(&m_mutex);
-        if (m_toIndex.isEmpty()) {
-            if (--m_nIndexInProgress == 0)
-                indexEnd();
-            return false;
-        }
-        toIndex = m_toIndex.last();
-        m_toIndex.removeLast();
-    }
-    bool hasMore = false;
-    {
-        auto guard = qScopeGuard([this, &hasMore]() {
-            QMutexLocker l(&m_mutex);
-            if (m_toIndex.isEmpty()) {
-                if (--m_nIndexInProgress == 0)
-                    indexEnd();
-                hasMore = false;
-            } else {
-                hasMore = true;
-            }
-        });
-        indexDirectory(toIndex.path, toIndex.leftDepth);
-    }
-    return hasMore;
-}
-
 void QQmlCodeModel::openNeedUpdate()
 {
     qCDebug(codeModelLog) << "openNeedUpdate";
-    const int maxIndexThreads = 1;
+    const int maxThreads = 1;
     {
         QMutexLocker l(&m_mutex);
-        if (m_openDocumentsToUpdate.isEmpty() || m_nUpdateInProgress >= maxIndexThreads)
+        if (m_openDocumentsToUpdate.isEmpty() || m_nUpdateInProgress >= maxThreads)
             return;
         if (++m_nUpdateInProgress == 1)
             openUpdateStart();

src/qmlls/qqmlcodemodel_p.h

@@ -112,8 +112,6 @@ class QQmlCodeModel : public QObject
     OpenDocument openDocumentByUrl(const QByteArray &url);
 
     void openNeedUpdate();
-    void indexNeedsUpdate();
-    void addDirectoriesToIndex(const QStringList &paths, QLanguageServer *server);
     void addOpenToUpdate(const QByteArray &);
     void removeDirectory(const QString &path);
     // void updateDocument(const OpenDocument &doc);
@@ -149,13 +147,6 @@ class QQmlCodeModel : public QObject
     void documentationRootPathChanged(const QString &path);
 
 private:
-    void indexDirectory(const QString &path, int depthLeft);
-    int indexEvalProgress() const; // to be called in the mutex
-    void indexStart(); // to be called in the mutex
-    void indexEnd(); // to be called in the mutex
-    void indexSendProgress(int progress);
-    bool indexCancelled();
-    bool indexSome();
     void addDirectory(const QString &path, int leftDepth);
     bool openUpdateSome();
     void openUpdateStart();
@@ -169,11 +160,6 @@ class QQmlCodeModel : public QObject
 
     mutable QMutex m_mutex;
     State m_state = State::Running;
-    int m_lastIndexProgress = 0;
-    int m_nIndexInProgress = 0;
-    QList<ToIndex> m_toIndex;
-    int m_indexInProgressCost = 0;
-    int m_indexDoneCost = 0;
     int m_nUpdateInProgress = 0;
     QStringList m_importPaths;
     QQmlJS::Dom::DomItem m_currentEnv;

src/qmlls/qworkspace.cpp

@@ -19,7 +19,7 @@ void WorkspaceHandlers::registerHandlers(QLanguageServer *server, QLanguageServe
 {
     QObject::connect(server->notifySignals(),
                      &QLspNotifySignals::receivedDidChangeWorkspaceFoldersNotification, this,
-                     [server, this](const DidChangeWorkspaceFoldersParams &params) {
+                     [this](const DidChangeWorkspaceFoldersParams &params) {
                          const WorkspaceFoldersChangeEvent &event = params.event;
 
                          const QList<WorkspaceFolder> &removed = event.removed;
@@ -32,14 +32,10 @@ void WorkspaceHandlers::registerHandlers(QLanguageServer *server, QLanguageServe
                          m_codeModel->removeRootUrls(toRemove);
                          const QList<WorkspaceFolder> &added = event.added;
                          QList<QByteArray> toAdd;
-                         QStringList pathsToAdd;
                          for (const WorkspaceFolder &folder : added) {
                              toAdd.append(QQmlLSUtils::lspUriToQmlUrl(folder.uri));
-                             pathsToAdd.append(m_codeModel->url2Path(
-                                     QQmlLSUtils::lspUriToQmlUrl(folder.uri)));
                          }
                          m_codeModel->addRootUrls(toAdd);
-                         m_codeModel->addDirectoriesToIndex(pathsToAdd, server);
                      });
 
     QObject::connect(server->notifySignals(),
@@ -165,8 +161,6 @@ void WorkspaceHandlers::clientInitialized(QLanguageServer *server)
             rootPaths.insert(workspaceUrl.toLocalFile());
         }
     }
-    if (m_status == Status::Indexing)
-        m_codeModel->addDirectoriesToIndex(QStringList(rootPaths.begin(), rootPaths.end()), server);
 }
 
 QT_END_NAMESPACE

src/qmlls/qworkspace_p.h

@@ -24,7 +24,6 @@ class WorkspaceHandlers : public QLanguageServerModule
 {
     Q_OBJECT
 public:
-    enum class Status { NoIndex, Indexing };
     WorkspaceHandlers(QmlLsp::QQmlCodeModel *codeModel) : m_codeModel(codeModel) { }
     QString name() const override;
     void registerHandlers(QLanguageServer *server, QLanguageServerProtocol *protocol) override;
@@ -35,7 +34,6 @@ public Q_SLOTS:
 
 private:
     QmlLsp::QQmlCodeModel *m_codeModel = nullptr;
-    Status m_status = Status::NoIndex;
 };
 
 QT_END_NAMESPACE