File indexing completed on 2024-04-28 04:37:28

 /*
     SPDX-FileCopyrightText: 2010 Dmitry Risenberg <dmitry.risenberg@gmail.com>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "watcheddocumentset.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/idocumentcontroller.h>
 #include <interfaces/idocument.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/topducontext.h>
 #include <project/interfaces/iprojectfilemanager.h>
 #include <project/projectmodel.h>
 
 #include <QFileInfo>
 
 namespace KDevelop
 {
 
 enum ActionFlag {
     DoUpdate = 1,
     DoEmit = 2
 };
 Q_DECLARE_FLAGS(ActionFlags, ActionFlag)
 Q_DECLARE_OPERATORS_FOR_FLAGS(ActionFlags)
 
 class WatchedDocumentSetPrivate : public QObject
 {
     Q_OBJECT
 
 public:
     using DocumentSet = WatchedDocumentSet::DocumentSet;
 
     explicit WatchedDocumentSetPrivate(WatchedDocumentSet* documentSet)
         : m_documentSet(documentSet)
         , m_showImports(false)
     {
         connect(DUChain::self(), &DUChain::updateReady, this, &WatchedDocumentSetPrivate::updateReady);
     }
 
     inline bool showImports() const
     {
         return m_showImports;
     }
 
     void setShowImports(bool showImports)
     {
         if (m_showImports == showImports)
             return;
 
         DocumentSet oldImports = m_imports;
 
         m_showImports = showImports;
         updateImports();
 
         if (m_imports != oldImports)
             emit m_documentSet->changed();
     }
 
     inline const DocumentSet& documents() const
     {
         return m_documents;
     }
 
     inline const DocumentSet& imports() const
     {
         return m_imports;
     }
 
     inline void doUpdate(ActionFlags flags)
     {
         if (flags.testFlag(DoUpdate))
             updateImports();
 
         if (flags.testFlag(DoEmit))
             emit m_documentSet->changed();
     }
 
     void setDocuments(const DocumentSet& docs, ActionFlags flags = {})
     {
         m_documents = docs;
         doUpdate(flags);
     }
 
     bool addDocument(const IndexedString& doc, ActionFlags flags = {})
     {
         if (m_documents.contains(doc))
             return false;
 
         m_documents.insert(doc);
         doUpdate(flags);
         return true;
     }
 
     bool delDocument(const IndexedString& doc, ActionFlags flags = {})
     {
         const auto documentIt = m_documents.find(doc);
         if (documentIt == m_documents.end())
             return false;
 
         m_documents.erase(documentIt);
         doUpdate(flags);
         return true;
     }
 
     void renameDocument(const IndexedString& previousUrl, const IndexedString& currentUrl, ActionFlags flags = {})
     {
         const bool deleted = delDocument(previousUrl);
         const bool added = addDocument(currentUrl);
         if (deleted || added) {
             doUpdate(flags);
         }
     }
 
     void updateImports()
     {
         if (!m_showImports) {
             if (!m_imports.isEmpty()) {
                 m_imports.clear();
                 return;
             }
             return;
         }
 
         getImportsFromDUChain();
     }
 
     void clear()
     {
         m_documents.clear();
         m_imports.clear();
         emit m_documentSet->changed();
     }
 
 private:
     void getImportsFromDU(TopDUContext* context, QSet<TopDUContext*>& visitedContexts)
     {
         if (!context || visitedContexts.contains(context))
             return;
 
         visitedContexts.insert(context);
         const auto importedParentContexts = context->importedParentContexts();
         for (const DUContext::Import& ctx : importedParentContexts) {
             auto* topCtx = dynamic_cast<TopDUContext*>(ctx.context(nullptr));
 
             if (topCtx)
                 getImportsFromDU(topCtx, visitedContexts);
         }
     }
 
     void getImportsFromDUChain()
     {
         KDevelop::DUChainReadLocker lock;
         QSet<TopDUContext*> visitedContexts;
 
         m_imports.clear();
         for (const IndexedString& doc : qAsConst(m_documents)) {
             TopDUContext* ctx = DUChain::self()->chainForDocument(doc);
             getImportsFromDU(ctx, visitedContexts);
             visitedContexts.remove(ctx);
         }
 
         for (TopDUContext* ctx : qAsConst(visitedContexts)) {
             m_imports.insert(ctx->url());
         }
     }
 
     void updateReady(const IndexedString& doc, const ReferencedTopDUContext&)
     {
         if (!m_showImports || !m_documents.contains(doc))
             return;
 
         DocumentSet oldImports = m_imports;
 
         updateImports();
         if (m_imports != oldImports)
             emit m_documentSet->changed();
     }
 
     WatchedDocumentSet* m_documentSet;
 
     DocumentSet m_documents;
     DocumentSet m_imports;
 
     bool m_showImports;
 };
 
 WatchedDocumentSet::WatchedDocumentSet(QObject* parent)
     : QObject(parent)
     , d_ptr(new WatchedDocumentSetPrivate(this))
 {
 }
 
 WatchedDocumentSet::~WatchedDocumentSet()
 {
 }
 
 bool WatchedDocumentSet::showImports() const
 {
     Q_D(const WatchedDocumentSet);
 
     return d->showImports();
 }
 
 void WatchedDocumentSet::setShowImports(bool showImports)
 {
     Q_D(WatchedDocumentSet);
 
     d->setShowImports(showImports);
 }
 
 void WatchedDocumentSet::setCurrentDocument(const IndexedString&)
 {
 }
 
 WatchedDocumentSet::DocumentSet WatchedDocumentSet::get() const
 {
     Q_D(const WatchedDocumentSet);
 
     return d->documents();
 }
 
 WatchedDocumentSet::DocumentSet WatchedDocumentSet::imports() const
 {
     Q_D(const WatchedDocumentSet);
 
     return d->imports();
 }
 
 CurrentDocumentSet::CurrentDocumentSet(const IndexedString& document, QObject* parent)
     : WatchedDocumentSet(parent)
 {
     Q_D(WatchedDocumentSet);
 
     d->setDocuments({document}, DoUpdate);
 }
 
 void CurrentDocumentSet::setCurrentDocument(const IndexedString& url)
 {
     Q_D(WatchedDocumentSet);
 
     d->setDocuments({url}, DoUpdate | DoEmit);
 }
 
 ProblemScope CurrentDocumentSet::scope() const
 {
     return CurrentDocument;
 }
 
 OpenDocumentSet::OpenDocumentSet(QObject* parent)
     : WatchedDocumentSet(parent)
 {
     Q_D(WatchedDocumentSet);
 
     const auto documents = ICore::self()->documentController()->openDocuments();
     for (IDocument* doc : documents) {
         d->addDocument(IndexedString(doc->url()));
     }
     d->updateImports();
 
     connect(ICore::self()->documentController(), &IDocumentController::documentClosed, this, &OpenDocumentSet::documentClosed);
     connect(ICore::self()->documentController(), &IDocumentController::textDocumentCreated, this, &OpenDocumentSet::documentCreated);
     connect(ICore::self()->documentController(), &IDocumentController::documentUrlChanged, this,
             &OpenDocumentSet::documentUrlChanged);
 }
 
 void OpenDocumentSet::documentClosed(IDocument* doc)
 {
     Q_D(WatchedDocumentSet);
 
     d->delDocument(IndexedString(doc->url()), DoUpdate | DoEmit);
 }
 
 void OpenDocumentSet::documentCreated(IDocument* doc)
 {
     Q_D(WatchedDocumentSet);
 
     d->addDocument(IndexedString(doc->url()), DoUpdate | DoEmit);
 }
 
 void OpenDocumentSet::documentUrlChanged(IDocument* doc, const QUrl& previousUrl)
 {
     Q_D(WatchedDocumentSet);
 
     if (doc->textDocument()) {
         d->renameDocument(IndexedString{previousUrl}, IndexedString{doc->url()}, DoUpdate | DoEmit);
     }
 }
 
 ProblemScope OpenDocumentSet::scope() const
 {
     return OpenDocuments;
 }
 
 ProjectSet::ProjectSet(QObject* parent)
     : WatchedDocumentSet(parent)
 {
     // Multiple projects can share a project file manager, e.g. CMakeManager. When a project P that
     // is being opened uses an already tracked project file manager, fileAdded() is invoked for each file
     // that belongs to P. If P contains thousands of files with many problems, KDevelop UI freezes,
     // because the ProblemReporterModel model is reset on each document set change.
     // Suspend adding files while a project is being opened. Derived classes connect to the signal
     // IProjectController::projectOpened and add all of the newly opened project's files at once, if needed.
     const auto* const projectController = ICore::self()->projectController();
     connect(projectController, &IProjectController::projectAboutToBeOpened, this, [this] {
         m_pauseAddingFiles = true;
     });
     const auto projectOpeningOver = [this] {
         m_pauseAddingFiles = false;
     };
     connect(projectController, &IProjectController::projectOpened, this, projectOpeningOver);
     connect(projectController, &IProjectController::projectOpeningAborted, this, projectOpeningOver);
 }
 
 void ProjectSet::fileAdded(ProjectFileItem* file)
 {
     Q_D(WatchedDocumentSet);
 
     if (m_pauseAddingFiles) {
         return;
     }
 
     const auto path = IndexedString(file->indexedPath());
     if (include(path)) {
         d->addDocument(path, DoUpdate | DoEmit);
     }
 }
 
 void ProjectSet::fileRemoved(ProjectFileItem* file)
 {
     Q_D(WatchedDocumentSet);
 
     d->delDocument(IndexedString(file->indexedPath()), DoUpdate | DoEmit);
 }
 
 void ProjectSet::fileRenamed(const Path& oldFile, ProjectFileItem* newFile)
 {
     Q_D(WatchedDocumentSet);
 
     d->delDocument(IndexedString(oldFile.pathOrUrl()));
     fileAdded(newFile);
 }
 
 static const QObject* qobjectProjectFileManager(const IProjectFileManager* projectFileManager)
 {
     // The implementation should derive from QObject somehow
     return dynamic_cast<const QObject*>(projectFileManager);
 }
 
 void ProjectSet::trackProjectFiles(const IProjectFileManager* projectFileManager)
 {
     auto* const fileManager = qobjectProjectFileManager(projectFileManager);
     if (!fileManager) {
         return;
     }
     // can't use new signal/slot syntax here, IProjectFileManager is no a QObject
     connect(fileManager, SIGNAL(fileAdded(KDevelop::ProjectFileItem*)), this,
             SLOT(fileAdded(KDevelop::ProjectFileItem*)));
     connect(fileManager, SIGNAL(fileRemoved(KDevelop::ProjectFileItem*)), this,
             SLOT(fileRemoved(KDevelop::ProjectFileItem*)));
     connect(fileManager, SIGNAL(fileRenamed(KDevelop::Path, KDevelop::ProjectFileItem*)), this,
             SLOT(fileRenamed(KDevelop::Path, KDevelop::ProjectFileItem*)));
 }
 
 void ProjectSet::stopTrackingProjectFiles(const IProjectFileManager* projectFileManager)
 {
     auto* const fileManager = qobjectProjectFileManager(projectFileManager);
     if (!fileManager) {
         return;
     }
     fileManager->disconnect(this);
 }
 
 CurrentProjectSet::CurrentProjectSet(const IndexedString& document, QObject* parent)
     : ProjectSet(parent)
     , m_currentDocumentUrl(document.toUrl())
 {
     handleCurrentDocumentChange();
 
     // Opening or closing a project can change m_currentDocument's associated project.
     const auto* const projectController = ICore::self()->projectController();
     connect(projectController, &IProjectController::projectOpened, this,
             &CurrentProjectSet::handleCurrentDocumentChange);
     connect(projectController, &IProjectController::projectClosed, this,
             &CurrentProjectSet::handleCurrentDocumentChange);
 }
 
 void CurrentProjectSet::setCurrentDocument(const IndexedString& url)
 {
     m_currentDocumentUrl = url.toUrl();
     handleCurrentDocumentChange();
 }
 
 void CurrentProjectSet::handleCurrentDocumentChange()
 {
     Q_D(WatchedDocumentSet);
 
     const auto* const projectForUrl = ICore::self()->projectController()->findProjectForUrl(m_currentDocumentUrl);
     if (projectForUrl == m_currentProject) {
         return;
     }
 
     if (m_currentProject) {
         stopTrackingProjectFiles(m_currentProject->projectFileManager());
     }
     m_currentProject = projectForUrl;
 
     if (m_currentProject) {
         d->setDocuments(m_currentProject->fileSet(), DoUpdate | DoEmit);
         trackProjectFiles(m_currentProject->projectFileManager());
     } else {
         d->clear();
     }
 }
 
 bool CurrentProjectSet::include(const IndexedString& url) const
 {
     return m_currentProject && m_currentProject->fileSet().contains(url);
 }
 
 ProblemScope CurrentProjectSet::scope() const
 {
     return CurrentProject;
 }
 
 AllProjectSet::AllProjectSet(QObject* parent)
     : AllProjectSet(InitFlag::LoadOnInit, parent)
 {
 }
 
 AllProjectSet::AllProjectSet(InitFlag initFlag, QObject* parent)
     : ProjectSet(parent)
 {
     switch (initFlag) {
     case InitFlag::LoadOnInit:
         reload();
         break;
     case InitFlag::SkipLoadOnInit:
         break;
     }
 
     const auto* const projectController = ICore::self()->projectController();
     connect(projectController, &IProjectController::projectOpened, this, &AllProjectSet::projectOpened);
     // When a project is closed, simply reloading can be more efficient than removing the closed project's
     // files, especially if this was the only open project. Furthermore, a single file can belong to
     // multiple open projects. In this corner case removing the closed project's files is incorrect.
     connect(projectController, &IProjectController::projectClosed, this, &AllProjectSet::reload);
 }
 
 void AllProjectSet::reload()
 {
     Q_D(WatchedDocumentSet);
 
     d->clear();
 
     QSet<const IProjectFileManager*> openProjectFileManagers;
 
     const auto projects = ICore::self()->projectController()->projects();
     for (const IProject* project : projects) {
         addProjectFiles(*project);
         openProjectFileManagers.insert(project->projectFileManager());
     }
 
     if (m_trackedProjectFileManagers != openProjectFileManagers) {
         const auto removedFileManagers = m_trackedProjectFileManagers - openProjectFileManagers;
         for (auto* f : removedFileManagers) {
             stopTrackingProjectFiles(f);
         }
 
         const auto addedFileManagers = openProjectFileManagers - m_trackedProjectFileManagers;
         for (auto* f : addedFileManagers) {
             trackProjectFiles(f);
         }
 
         m_trackedProjectFileManagers = openProjectFileManagers;
     }
 
     d->updateImports();
     emit changed();
 }
 
 void AllProjectSet::projectOpened(const IProject* project)
 {
     Q_D(WatchedDocumentSet);
 
     addProjectFiles(*project);
 
     const auto* const projectFileManager = project->projectFileManager();
     if (!m_trackedProjectFileManagers.contains(projectFileManager)) {
         trackProjectFiles(projectFileManager);
         m_trackedProjectFileManagers.insert(projectFileManager);
     }
 
     d->updateImports();
     emit changed();
 }
 
 void AllProjectSet::addProjectFiles(const IProject& project)
 {
     Q_D(WatchedDocumentSet);
 
     const auto fileSet = project.fileSet();
     for (const IndexedString& document : fileSet) {
         if (include(document)) {
             d->addDocument(document);
         }
     }
 }
 
 ProblemScope AllProjectSet::scope() const
 {
     return AllProjects;
 }
 
 DocumentsInPathSet::DocumentsInPathSet(const QString& path, QObject* parent)
     : AllProjectSet(InitFlag::SkipLoadOnInit, parent)
     , m_path(path)
 {
     reload();
 }
 
 ProblemScope DocumentsInPathSet::scope() const
 {
     return DocumentsInPath;
 }
 
 void DocumentsInPathSet::setPath(const QString& path)
 {
     if (m_path == path) {
         return;
     }
 
     m_path = path;
     reload();
 }
 
 bool DocumentsInPathSet::include(const IndexedString& path) const
 {
     if (m_path.isEmpty()) {
         return true;
     }
 
     return path.str().contains(m_path, Qt::CaseInsensitive);
 }
 
 DocumentsInCurrentPathSet::DocumentsInCurrentPathSet(const IndexedString& document, QObject* parent)
     : DocumentsInPathSet(QFileInfo(document.str()).path(), parent)
 {
 }
 
 ProblemScope DocumentsInCurrentPathSet::scope() const
 {
     return DocumentsInCurrentPath;
 }
 
 void DocumentsInCurrentPathSet::setCurrentDocument(const IndexedString& document)
 {
     setPath(QFileInfo(document.str()).path());
 }
 
 BypassSet::BypassSet(QObject* parent)
     : WatchedDocumentSet(parent)
 {
 }
 
 ProblemScope BypassSet::scope() const
 {
     return BypassScopeFilter;
 }
 
 }
 
 #include "watcheddocumentset.moc"
 #include "moc_watcheddocumentset.cpp"