File indexing completed on 2024-05-19 15:46:45

 /*
     SPDX-FileCopyrightText: 2012 Milian Wolff <mail@milianw.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "parsesession.h"
 #include "debugvisitor.h"
 #include "cache.h"
 
 #include <qmljs/parser/qmljsast_p.h>
 #include <qmljs/parser/qmljsengine_p.h>
 
 #include <language/duchain/stringhelpers.h>
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/declaration.h>
 #include <language/backgroundparser/backgroundparser.h>
 #include <language/editor/documentrange.h>
 #include <interfaces/ilanguagecontroller.h>
 #include <interfaces/icore.h>
 
 using namespace KDevelop;
 
 IndexedString ParseSession::languageString()
 {
     static const IndexedString langString("QML/JS");
     return langString;
 }
 
 bool isSorted(const QList<QmlJS::AST::SourceLocation>& locations)
 {
     if (locations.size() <= 1) {
         return true;
     }
     for(int i = 1; i < locations.size(); ++i) {
         if (locations.at(i).begin() <= locations.at(i-1).begin()) {
             return false;
         }
     }
     return true;
 }
 
 QmlJS::Dialect ParseSession::guessLanguageFromSuffix(const QString& path)
 {
     if (path.endsWith(QLatin1String(".js"))) {
         return QmlJS::Dialect::JavaScript;
     } else if (path.endsWith(QLatin1String(".json"))) {
         return QmlJS::Dialect::Json;
     } else {
         return QmlJS::Dialect::Qml;
     }
 }
 
 ParseSession::ParseSession(const IndexedString& url, const QString& contents, int priority)
 : m_url(url),
   m_ownPriority(priority),
   m_allDependenciesSatisfied(true)
 {
     const QString path = m_url.str();
     m_doc = QmlJS::Document::create(path, guessLanguageFromSuffix(path));
     m_doc->setSource(contents);
     m_doc->parse();
     Q_ASSERT(isSorted(m_doc->engine()->comments()));
 
     // Parse the module name and the version of url (this is used only when the file
     // is a QML module, but doesn't break for JavaScript files)
     m_baseName = QString::fromUtf8(m_url.byteArray())
         .section(QLatin1Char('/'), -1, -1)                   // Base name
         .section(QLatin1Char('.'), 0, -2);                   // Without extension
 }
 
 bool ParseSession::isParsedCorrectly() const
 {
     return m_doc->isParsedCorrectly();
 }
 
 QmlJS::AST::Node* ParseSession::ast() const
 {
     return m_doc->ast();
 }
 
 IndexedString ParseSession::url() const
 {
     return m_url;
 }
 
 QString ParseSession::moduleName() const
 {
     return m_baseName;
 }
 
 void ParseSession::addProblem(QmlJS::AST::Node* node,
                               const QString& message,
                               IProblem::Severity severity)
 {
     ProblemPointer p(new Problem);
 
     p->setDescription(message);
     p->setSeverity(severity);
     p->setSource(IProblem::SemanticAnalysis);
     p->setFinalLocation(DocumentRange(m_url, editorFindRange(node, node).castToSimpleRange()));
 
     m_problems << p;
 }
 
 QList<ProblemPointer> ParseSession::problems() const
 {
     QList<ProblemPointer> problems = m_problems;
 
     const auto diagnosticMessages = m_doc->diagnosticMessages();
     problems.reserve(problems.size() + diagnosticMessages.size());
     for (const auto& msg : diagnosticMessages) {
         ProblemPointer p(new Problem);
         p->setDescription(msg.message);
         p->setSeverity(IProblem::Error);
         p->setSource(IProblem::Parser);
         p->setFinalLocation(DocumentRange(m_url, locationToRange(msg.loc).castToSimpleRange()));
         problems << p;
     }
 
     return problems;
 }
 
 QString ParseSession::symbolAt(const QmlJS::AST::SourceLocation& location) const
 {
     return m_doc->source().mid(location.offset, location.length);
 }
 
 QmlJS::Dialect ParseSession::language() const
 {
     return m_doc->language();
 }
 
 bool compareSourceLocation(const QmlJS::AST::SourceLocation& l,
                            const QmlJS::AST::SourceLocation& r)
 {
     return l.begin() < r.begin();
 }
 
 QString ParseSession::commentForLocation(const QmlJS::AST::SourceLocation& location) const
 {
     // find most recent comment in sorted list of comments
     const QList< QmlJS::AST::SourceLocation >& comments = m_doc->engine()->comments();
     auto it = std::lower_bound(
         comments.constBegin(),
         comments.constEnd(),
         location, compareSourceLocation
     );
 
     if (it == comments.constBegin()) {
         return QString();
     }
 
     // lower bound returns the place of insertion,
     // we want the comment before that
     it--;
     RangeInRevision input = locationToRange(location);
     RangeInRevision match = locationToRange(*it);
     if (match.end.line != input.start.line - 1 && match.end.line != input.start.line) {
         return QString();
     }
 
     ///TODO: merge consecutive //-style comments?
     return formatComment(symbolAt(*it));
 }
 
 RangeInRevision ParseSession::locationToRange(const QmlJS::AST::SourceLocation& location) const
 {
     const int linesInLocation = m_doc->source().midRef(location.offset, location.length).count(QLatin1Char('\n'));
     return RangeInRevision(location.startLine - 1, location.startColumn - 1,
                            location.startLine - 1 + linesInLocation, location.startColumn - 1 + location.length);
 }
 
 RangeInRevision ParseSession::locationsToRange(const QmlJS::AST::SourceLocation& locationFrom,
                                                const QmlJS::AST::SourceLocation& locationTo) const
 {
     return RangeInRevision(locationToRange(locationFrom).start,
                            locationToRange(locationTo).end);
 }
 
 RangeInRevision ParseSession::locationsToInnerRange(const QmlJS::AST::SourceLocation& locationFrom,
                                                     const QmlJS::AST::SourceLocation& locationTo) const
 {
     return RangeInRevision(locationToRange(locationFrom).end,
                            locationToRange(locationTo).start);
 }
 
 RangeInRevision ParseSession::editorFindRange(QmlJS::AST::Node* fromNode, QmlJS::AST::Node* toNode) const
 {
     return locationsToRange(fromNode->firstSourceLocation(), toNode->lastSourceLocation());
 }
 
 void ParseSession::setContextOnNode(QmlJS::AST::Node* node, DUContext* context)
 {
     m_astToContext.insert(node, DUContextPointer(context));
 }
 
 DUContext* ParseSession::contextFromNode(QmlJS::AST::Node* node) const
 {
     return m_astToContext.value(node, DUContextPointer()).data();
 }
 
 bool ParseSession::allDependenciesSatisfied() const
 {
     return m_allDependenciesSatisfied;
 }
 
 ReferencedTopDUContext ParseSession::contextOfFile(const QString& fileName)
 {
     ReferencedTopDUContext res = contextOfFile(fileName, m_url, m_ownPriority);
 
     if (!res) {
         // The file was not yet present in the DUChain, store this information.
         // This will prevent the second parsing pass from running (it would be
         // useless as the file will be re-parsed when res will become available)
         m_allDependenciesSatisfied = false;
     }
 
     return res;
 }
 
 ReferencedTopDUContext ParseSession::contextOfFile(const QString& fileName,
                                                    const KDevelop::IndexedString& url,
                                                    int ownPriority)
 {
     if (fileName.isEmpty()) {
         return ReferencedTopDUContext();
     }
 
     // Get the top context of this module file
     DUChainReadLocker lock;
     IndexedString moduleFileString(fileName);
     ReferencedTopDUContext moduleContext = DUChain::self()->chainForDocument(moduleFileString);
 
     lock.unlock();
     QmlJS::Cache::instance().addDependency(url, moduleFileString);
 
     if (!moduleContext) {
         // Queue the file on which we depend with a lower priority than the one of this file
         scheduleForParsing(moduleFileString, ownPriority - 1);
 
         // Register a dependency between this file and the imported one
         return ReferencedTopDUContext();
     } else {
         return moduleContext;
     }
 }
 
 void ParseSession::reparseImporters()
 {
     const auto& files = QmlJS::Cache::instance().filesThatDependOn(m_url);
     for (const KDevelop::IndexedString& file : files) {
         scheduleForParsing(file, m_ownPriority);
     }
 }
 
 void ParseSession::scheduleForParsing(const IndexedString& url, int priority)
 {
     BackgroundParser* bgparser = KDevelop::ICore::self()->languageController()->backgroundParser();
     const auto features = TopDUContext::ForceUpdate | TopDUContext::AllDeclarationsContextsAndUses;
 
     if (bgparser->isQueued(url)) {
         bgparser->removeDocument(url);
     }
 
     bgparser->addDocument(url, features, priority, nullptr, ParseJob::FullSequentialProcessing);
 }
 
 void ParseSession::dumpNode(QmlJS::AST::Node* node) const
 {
     DebugVisitor v(this);
     v.startVisiting(node);
 }