Revision control
++ // Copyright (C) 2025 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++ // Qt-Security score:significant reason:trusted-sources
++
++ #include "qqmlcodemodelmanager_p.h"
++ #include "qqmllsplugin_p.h"
++
++ #include <QtQmlCompiler/private/qqmljsutils_p.h>
++
++ #include <memory>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QmlLsp {
++
++ Q_STATIC_LOGGING_CATEGORY(lcCodeModelManager, "qt.languageserver.codemodelmanager")
++
++ using namespace QQmlJS::Dom;
++ using namespace Qt::StringLiterals;
++
++ void QQmlCodeModelManager::onCMakeProberFinished(int exitCode, QProcess::ExitStatus exitStatus)
++ {
++ if (m_cmakeStatus == DoesNotHaveCMake)
++ return;
++
++ if (exitStatus != QProcess::NormalExit || exitCode != 0) {
++ disableCMakeCalls();
++ return;
++ }
++ m_cmakeStatus = HasCMake;
++ for (const auto &ws : m_workspaces)
++ ws.codeModel->tryEnableCMakeCalls(&m_processScheduler);
++ }
++
++ /*!
++ \internal
++ Enable and initialize the functionality that uses CMake, if CMake exists.
++
++ \note Set the buildpaths before calling this method!
++ */
++ void QQmlCodeModelManager::tryEnableCMakeCalls()
++ {
++ m_cmakeStatus = IsProbingCMake;
++
++ m_cmakeProber.setProgram(u"cmake"_s);
++ m_cmakeProber.setArguments({ u"--version"_s });
++ QObject::connect(&m_cmakeProber, &QProcess::finished, this,
++ &QQmlCodeModelManager::onCMakeProberFinished);
++ QObject::connect(&m_cmakeProber, &QProcess::errorOccurred, this,
++ &QQmlCodeModelManager::disableCMakeCalls);
++
++ m_cmakeProber.start();
++ }
++
++ QQmlCodeModelManager::QQmlCodeModelManager(QObject *parent, QQmlToolingSharedSettings *settings)
++ : QObject{ parent }, m_settings(settings), m_pluginLoader(QmlLSPluginInterface_iid, u"/qmlls"_s)
++ {
++ const QByteArray defaultCodeModel;
++ appendWorkspace(defaultCodeModel, ManagedByServer);
++ connect(&m_processScheduler, &QProcessScheduler::done, this,
++ &QQmlCodeModelManager::onBuildFinished);
++ connect(&m_processScheduler, &QProcessScheduler::started, this,
++ &QQmlCodeModelManager::backgroundBuildStarted);
++ connect(&m_processScheduler, &QProcessScheduler::cancelled, this,
++ &QQmlCodeModelManager::backgroundBuildCancelled);
++ }
++
++ void QQmlCodeModelManager::onBuildFinished(const QByteArray &url)
++ {
++ qCInfo(lcCodeModelManager) << "Build for workspace" << url << "finished.";
++ auto it = findWorkspace(url);
++ if (it == fallbackWorkspace() || it == m_workspaces.end()) {
++ emit backgroundBuildFinished(url);
++ return;
++ }
++
++ // refresh information obtained from build folder, like .qmlls.build.ini or resource files
++ const QStringList buildPaths = it->codeModel->buildPaths();
++ m_buildInformation.loadSettingsFrom(buildPaths, ForceUpdate);
++ setBuildPathsOn(&*it, buildPaths, AppendPathsFromFallback);
++ it->codeModel->reloadAllOpenFiles();
++ emit backgroundBuildFinished(url);
++ emit configurationChanged();
++ }
++
++ void QQmlCodeModelManager::prepareForShutdown()
++ {
++ for (auto it = m_workspaces.begin(), end = m_workspaces.end(); it != end; ++it)
++ it->codeModel->prepareForShutdown();
++ }
++
++ QQmlCodeModelManager::~QQmlCodeModelManager()
++ {
++ m_cmakeProber.kill();
++ m_cmakeProber.waitForFinished();
++ prepareForShutdown();
++ }
++
++ QQmlCodeModelManager::WorkspaceIterator
++ QQmlCodeModelManager::findWorkspaceForFile(const QByteArray &url)
++ {
++ Q_ASSERT(!m_workspaces.empty());
++ // if file was already opened before: re-use same CodeModel as last time
++ if (auto it = m_file2CodeModel.find(url); it != m_file2CodeModel.end()) {
++ const auto result = findWorkspace(it->second);
++ Q_ASSERT(result != m_workspaces.end());
++ return result;
++ }
++
++ long longestRootUrl = 0;
++ WorkspaceIterator result = m_workspaces.begin();
++ for (auto it = m_workspaces.begin(), end = m_workspaces.end(); it != end; ++it) {
++ if (it->toBeClosed)
++ continue;
++ const QByteArray rootUrl = it->url;
++ if (!url.startsWith(rootUrl))
++ continue;
++
++ if (rootUrl.size() == url.size())
++ return it;
++
++ const long rootUrlLength = rootUrl.length();
++ if (rootUrlLength > longestRootUrl) {
++ longestRootUrl = rootUrlLength;
++ result = it;
++ }
++ }
++
++ // check .qmlls.build.ini for a potentially better match
++ if (const ModuleSetting moduleSetting =
++ m_buildInformation.settingFor(QUrl::fromEncoded(url).toLocalFile());
++ !moduleSetting.importPaths.isEmpty()) {
++ const QByteArray rootUrl = QUrl::fromLocalFile(moduleSetting.sourceFolder).toEncoded();
++ if (longestRootUrl < rootUrl.size()) {
++ appendWorkspace(rootUrl, ManagedByServer);
++ return --m_workspaces.end();
++ }
++ }
++ Q_ASSERT(result != m_workspaces.end());
++ return result;
++ }
++
++ QQmlCodeModel *QQmlCodeModelManager::findCodeModelForFile(const QByteArray &url)
++ {
++ return findWorkspaceForFile(url)->codeModel.get();
++ }
++
++ QQmlCodeModelManager::WorkspaceMutableIterator
++ QQmlCodeModelManager::findWorkspace(const QByteArray &url)
++ {
++ return std::find_if(m_workspaces.begin(), m_workspaces.end(),
++ [&url](const QQmlWorkspace &ws) { return ws.url == url; });
++ }
++
++ void QQmlCodeModelManager::setBuildPathsOn(const QQmlWorkspace *ws, const QStringList &buildFolder,
++ SetBuildPathOption option)
++ {
++ ws->codeModel->setBuildPaths(
++ buildFolder
++ + (option == DontAppendPathsFromFallback ? QStringList{} : defaultBuildPaths()));
++
++ const QString file = QUrl::fromEncoded(ws->url).toLocalFile();
++ ws->codeModel->setImportPaths(
++ m_buildInformation.importPathsFor(file)
++ + (option == DontAppendPathsFromFallback ? QStringList{} : defaultImportPaths()));
++
++ if (const QStringList resourceFiles = m_buildInformation.resourceFilesFor(file);
++ !resourceFiles.isEmpty()) {
++ ws->codeModel->setResourceFiles(resourceFiles);
++ return;
++ }
++ // fallback for qt projects < 6.11 without resource files in their .qmlls.build.ini
++ const QStringList resourceFiles =
++ QQmlJSUtils::resourceFilesFromBuildFolders(ws->codeModel->buildPaths());
++ ws->codeModel->setResourceFiles(
++ resourceFiles
++ + (option == DontAppendPathsFromFallback ? QStringList{} : defaultResourceFiles()));
++ }
++
++ void QQmlCodeModelManager::appendWorkspace(const QByteArray &url, ManagedBy managedBy)
++ {
++ QQmlWorkspace ws;
++ ws.url = url;
++ ws.codeModel = std::make_unique<QQmlCodeModel>(url, this, m_settings);
++
++ // the non-fallback codemodel inherits the default values from the fallback codemodel
++ if (!url.isEmpty()) {
++ ws.codeModel->setCMakeJobs(defaultCMakeJobs());
++ ws.codeModel->setDocumentationRootPath(defaultDocumentationRootPath());
++
++ setBuildPathsOn(&ws, {}, AppendPathsFromFallback);
++ }
++
++ QObject::connect(ws.codeModel.get(), &QQmlCodeModel::updatedSnapshot, this,
++ &QQmlCodeModelManager::updatedSnapshot);
++ ws.managedByClient = managedBy == ManagedByClient;
++
++ switch (m_cmakeStatus) {
++ case DoesNotHaveCMake:
++ ws.codeModel->disableCMakeCalls();
++ break;
++ case HasCMake:
++ ws.codeModel->tryEnableCMakeCalls(&m_processScheduler);
++ break;
++ case IsProbingCMake:
++ // will be enabled once the CMake probing process finishes
++ break;
++ }
++ m_workspaces.emplace_back(std::move(ws));
++ }
++
++ QQmlCodeModelManager::WorkspaceIterator
++ QQmlCodeModelManager::workspaceFromBuildFolder(const QString &fileName,
++ const QStringList &buildFolders)
++ {
++ m_buildInformation.loadSettingsFrom(buildFolders);
++ const ModuleSetting setting = m_buildInformation.settingFor(fileName);
++ QByteArray url = QUrl::fromLocalFile(setting.sourceFolder).toEncoded();
++ if (auto it = findWorkspace(url); it != m_workspaces.end())
++ return it;
++ appendWorkspace(url, ManagedByServer);
++ return --m_workspaces.end();
++ }
++
++ void QQmlCodeModelManager::disableCMakeCalls()
++ {
++ m_cmakeStatus = DoesNotHaveCMake;
++ for (const auto &ws : m_workspaces)
++ ws.codeModel->disableCMakeCalls();
++ }
++
++ void QQmlCodeModelManager::cancelBackgroundBuild(const QByteArray &uri)
++ {
++ m_processScheduler.cancel(uri);
++ }
++
++ OpenDocumentSnapshot QQmlCodeModelManager::snapshotByUrl(const QByteArray &url)
++ {
++ return findCodeModelForFile(url)->snapshotByUrl(url);
++ }
++
++ void QQmlCodeModelManager::removeDirectory(const QByteArray &url)
++ {
++ findCodeModelForFile(url)->removeDirectory(url);
++ }
++
++ void QQmlCodeModelManager::newOpenFile(const QByteArray &url, int version, const QString &docText)
++ {
++ const auto ws = findWorkspaceForFile(url);
++ m_file2CodeModel[url] = ws->url;
++ ws->codeModel->newOpenFile(url, version, docText);
++ }
++
++ OpenDocument QQmlCodeModelManager::openDocumentByUrl(const QByteArray &url)
++ {
++ return findCodeModelForFile(url)->openDocumentByUrl(url);
++ }
++
++ RegisteredSemanticTokens &QQmlCodeModelManager::registeredTokens(const QByteArray &url)
++ {
++ return findCodeModelForFile(url)->registeredTokens();
++ }
++
++ void QQmlCodeModelManager::closeOpenFile(const QByteArray &url)
++ {
++ m_file2CodeModel.erase(url);
++ const auto it = findWorkspaceForFile(url);
++ it->codeModel->closeOpenFile(url);
++
++ // don't close the default workspace
++ if (it->url.isEmpty())
++ return;
++
++ // close empty WS when managed by server or when client marked ws as toBeClosed.
++ if ((it->managedByClient && it->toBeClosed) || !it->managedByClient) {
++ if (it->codeModel->isEmpty())
++ m_workspaces.erase(it);
++ }
++ }
++
++ QList<QByteArray> QQmlCodeModelManager::rootUrls() const
++ {
++ QList<QByteArray> result;
++ result.reserve(m_workspaces.size());
++ for (const QQmlWorkspace &ws : m_workspaces) {
++ result << ws.url;
++ }
++ return result;
++ }
++
++ void QQmlCodeModelManager::addRootUrls(const QList<QByteArray> &urls)
++ {
++ for (const QByteArray &url : urls) {
++ if (const auto it = findWorkspace(url); it != m_workspaces.end()) {
++ it->toBeClosed = false;
++ continue;
++ }
++
++ appendWorkspace(url, ManagedByClient);
++ }
++ }
++
++ void QQmlCodeModelManager::removeRootUrls(const QList<QByteArray> &urls)
++ {
++ for (const QByteArray &url : urls) {
++ if (auto it = findWorkspace(url); it != m_workspaces.end() && it->managedByClient)
++ it->toBeClosed = true;
++ }
++ }
++
++ QStringList QQmlCodeModelManager::importPathsForUrl(const QByteArray &url)
++ {
++ return findCodeModelForFile(url)->importPathsForUrl(url);
++ }
++
++ QStringList QQmlCodeModelManager::buildPathsForFileUrl(const QByteArray &url)
++ {
++ return findCodeModelForFile(url)->buildPathsForFileUrl(url);
++ }
++
++ QStringList QQmlCodeModelManager::resourceFilesForFileUrl(const QByteArray &url)
++ {
++ if (const QStringList result =
++ m_buildInformation.resourceFilesFor(QUrl::fromEncoded(url).toLocalFile());
++ !result.isEmpty()) {
++ return result;
++ }
++
++ // fallback, for standalone qmlls on projects targeting qt < 6.11
++ return findCodeModelForFile(url)->resourceFiles();
++ }
++
++ QByteArray QQmlCodeModelManager::shortestRootUrlForFile(const QByteArray &fileUrl) const
++ {
++ // fallback value for candidate is the empty url of the default workspace
++ QByteArray candidate;
++
++ // ignore the default workspace which is at the front of m_workspaces
++ Q_ASSERT(m_workspaces.size() > 0);
++ Q_ASSERT(m_workspaces.front().url.isEmpty());
++ auto it = std::find_if(
++ ++m_workspaces.cbegin(), m_workspaces.cend(),
++ [&fileUrl](const QQmlWorkspace &ws) { return fileUrl.startsWith(ws.url); });
++
++ if (it != m_workspaces.cend())
++ candidate = it->url;
++
++ for (; it != m_workspaces.cend(); ++it) {
++ if (it->url.length() < candidate.length() && fileUrl.startsWith(it->url))
++ candidate = it->url;
++ }
++ return candidate;
++ }
++
++ void QQmlCodeModelManager::setDocumentationRootPath(const QString &path)
++ {
++ // Note: this function can only be called after the fallback workspace was created but before
++ // all other potential workspaces are created, for example when setting the import paths set via
++ // commandline option or environment variable.
++ Q_ASSERT(m_workspaces.size() == 1);
++ for (const auto &ws : m_workspaces)
++ ws.codeModel->setDocumentationRootPath(path);
++ }
++
++ void QQmlCodeModelManager::setVerbose(bool verbose)
++ {
++ m_verbose = verbose;
++ for (const auto &ws : m_workspaces)
++ ws.codeModel->setVerbose(verbose);
++ }
++
++ void QQmlCodeModelManager::setCMakeJobs(int jobs)
++ {
++ for (const auto &ws : m_workspaces)
++ ws.codeModel->setCMakeJobs(jobs);
++ }
++
++ void QQmlCodeModelManager::setBuildPathsForRootUrl(const QByteArray &url, const QStringList &paths)
++ {
++ m_buildInformation.loadSettingsFrom(paths, ForceUpdate);
++
++ // build paths passed by -b have an empty url and apply to all workspaces
++ if (url.isEmpty()) {
++ setBuildPathsOn(&*fallbackWorkspace(), paths, DontAppendPathsFromFallback);
++ // make non-fallback workspaces get the fallback build path
++ for (auto it = beginNonFallbackWorkspace(), end = endNonFallbackWorkspace(); it != end;
++ ++it) {
++ setBuildPathsOn(&*it, {}, AppendPathsFromFallback);
++ }
++ emit configurationChanged();
++ return;
++ }
++
++ auto ws = findWorkspaceForFile(url);
++ setBuildPathsOn(&*ws, paths, AppendPathsFromFallback);
++ emit configurationChanged();
++ }
++
++ void QQmlCodeModelManager::addOpenToUpdate(const QByteArray &url)
++ {
++ findCodeModelForFile(url)->addOpenToUpdate(url, NormalUpdate);
++ }
++
++ void QQmlCodeModelManager::setImportPaths(const QStringList &paths)
++ {
++ // Note: this function can only be called after the fallback workspace was created but before
++ // all other potential workspaces are created, for example when setting the import paths set via
++ // commandline option or environment variable.
++ Q_ASSERT(m_workspaces.size() == 1);
++ for (const auto &ws : m_workspaces)
++ ws.codeModel->setImportPaths(paths);
++ }
++
++ HelpManager *QQmlCodeModelManager::helpManagerForUrl(const QByteArray &url)
++ {
++ return findCodeModelForFile(url)->helpManager();
++ }
++
++ } // namespace QmlLsp
++
++ QT_END_NAMESPACE