Revision control
++ // Copyright (C) 2020 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
++
++ #include "qqmldomitem_p.h"
++ #include "qqmldomtop_p.h"
++ #include "qqmldomexternalitems_p.h"
++ #include "qqmldommock_p.h"
++ #include "qqmldomelements_p.h"
++ #include "qqmldomastcreator_p.h"
++ #include "qqmldom_utils_p.h"
++
++ #include <QtQml/private/qqmljslexer_p.h>
++ #include <QtQml/private/qqmljsparser_p.h>
++ #include <QtQml/private/qqmljsengine_p.h>
++ #include <QtQml/private/qqmljsastvisitor_p.h>
++ #include <QtQml/private/qqmljsast_p.h>
++
++ #include <QtQmlCompiler/private/qqmljsutils_p.h>
++
++ #include <QtCore/QBasicMutex>
++ #include <QtCore/QCborArray>
++ #include <QtCore/QDebug>
++ #include <QtCore/QDir>
++ #include <QtCore/QFile>
++ #include <QtCore/QFileInfo>
++ #include <QtCore/QRegularExpression>
++ #include <QtCore/QScopeGuard>
++ #if QT_FEATURE_thread
++ # include <QtCore/QThread>
++ #endif
++
++ #include <memory>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ namespace QQmlJS {
++ namespace Dom {
++
++ using std::shared_ptr;
++
++
++ /*!
++ \internal
++ \brief QQml::Dom::DomTop::loadFile
++ \param filePath
++ the file path to load
++ \param logicalPath
++ the path from the
++ \param callback
++ a callback called with an canonical path, the old value, and the current value.
++ \param loadOptions are
++ if force is true the file is always read
++ */
++
++ Path DomTop::canonicalPath(const DomItem &) const
++ {
++ return canonicalPath();
++ }
++
++ DomItem DomTop::containingObject(const DomItem &) const
++ {
++ return DomItem();
++ }
++
++ bool DomTop::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
++ {
++ static QHash<QString, QString> knownFields;
++ static QBasicMutex m;
++ auto toField = [](const QString &f) mutable -> QStringView {
++ QMutexLocker l(&m);
++ if (!knownFields.contains(f))
++ knownFields[f] = f;
++ return knownFields[f];
++ };
++ bool cont = true;
++ auto objs = m_extraOwningItems;
++ auto itO = objs.cbegin();
++ auto endO = objs.cend();
++ while (itO != endO) {
++ cont = cont && visitor(PathEls::Field(toField(itO.key())), [&self, &itO]() {
++ return std::visit([&self](auto &&el) { return self.copy(el); }, *itO);
++ });
++ ++itO;
++ }
++ return cont;
++ }
++
++ void DomTop::clearExtraOwningItems()
++ {
++ QMutexLocker l(mutex());
++ m_extraOwningItems.clear();
++ }
++
++ QMap<QString, OwnerT> DomTop::extraOwningItems() const
++ {
++ QMutexLocker l(mutex());
++ QMap<QString, OwnerT> res = m_extraOwningItems;
++ return res;
++ }
++
++ /*!
++ \class QQmlJS::Dom::DomUniverse
++
++ \brief Represents a set of parsed/loaded modules libraries and a plugins
++
++ This can be used to share parsing and updates between several Dom models, and kickstart a model
++ without reparsing everything.
++
++ The universe is peculiar, because stepping into it from an environment looses the connection with
++ the environment.
++
++ This implementation is a placeholder, a later patch will introduce it.
++ */
++
++ ErrorGroups DomUniverse::myErrors()
++ {
++ static ErrorGroups groups = {{ DomItem::domErrorGroup, NewErrorGroup("Universe") }};
++ return groups;
++ }
++
++ DomUniverse::DomUniverse(const QString &universeName) : m_name(universeName) { }
++
++ std::shared_ptr<DomUniverse> DomUniverse::guaranteeUniverse(
++ const std::shared_ptr<DomUniverse> &univ)
++ {
++ const auto next = [] {
++ Q_CONSTINIT static std::atomic<int> counter(0);
++ return counter.fetch_add(1, std::memory_order_relaxed) + 1;
++ };
++ if (univ)
++ return univ;
++
++ return std::make_shared<DomUniverse>(
++ QLatin1String("universe") + QString::number(next()));
++ }
++
++ DomItem DomUniverse::create(const QString &universeName)
++ {
++ auto res = std::make_shared<DomUniverse>(universeName);
++ return DomItem(res);
++ }
++
++ Path DomUniverse::canonicalPath() const
++ {
++ return Path::fromRoot(u"universe");
++ }
++
++ bool DomUniverse::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
++ {
++ bool cont = true;
++ cont = cont && DomTop::iterateDirectSubpaths(self, visitor);
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name());
++ cont = cont && visitor(PathEls::Field(Fields::qmlFileWithPath), [this, &self]() {
++ return self.subMapItem(Map(
++ Path::fromField(Fields::qmlFileWithPath),
++ [this](const DomItem &map, const QString &key) {
++ return map.copy(qmlFileWithPath(key));
++ },
++ [this](const DomItem &) { return qmlFilePaths(); },
++ QLatin1String("QmlFile")));
++ });
++ cont = cont && visitor(PathEls::Field(Fields::jsFileWithPath), [this, &self]() {
++ return self.subMapItem(Map(
++ Path::fromField(Fields::jsFileWithPath),
++ [this](const DomItem &map, const QString &key) {
++ return map.copy(jsFileWithPath(key));
++ },
++ [this](const DomItem &) { return jsFilePaths(); }, QLatin1String("JsFile")));
++ });
++ return cont;
++ }
++
++ std::shared_ptr<OwningItem> DomUniverse::doCopy(const DomItem &) const
++ {
++ QRegularExpression r(QRegularExpression::anchoredPattern(QLatin1String(R"(.*Copy([0-9]*)$)")));
++ auto m = r.match(m_name);
++ QString newName;
++ if (m.hasMatch())
++ newName = QStringLiteral(u"%1Copy%2").arg(m_name).arg(m.captured(1).toInt() + 1);
++ else
++ newName = m_name + QLatin1String("Copy");
++ auto res = std::make_shared<DomUniverse>(newName);
++ return res;
++ }
++
++ static DomType fileTypeForPath(const DomItem &self, const QString &canonicalFilePath)
++ {
++ if (canonicalFilePath.endsWith(u".qml", Qt::CaseInsensitive)
++ || canonicalFilePath.endsWith(u".qmlannotation", Qt::CaseInsensitive)) {
++ return DomType::QmlFile;
++ } else if (canonicalFilePath.endsWith(u".js", Qt::CaseInsensitive)
++ || canonicalFilePath.endsWith(u".mjs", Qt::CaseInsensitive)) {
++ return DomType::JsFile;
++ }
++ else {
++ self.addError(DomUniverse::myErrors()
++ .error(QCoreApplication::translate("Dom::fileTypeForPath",
++ "Could not detect type of file %1")
++ .arg(canonicalFilePath))
++ .handle());
++ }
++ return DomType::Empty;
++ }
++
++ DomUniverse::LoadResult DomUniverse::loadFile(const FileToLoad &file, DomType fileType,
++ DomCreationOption creationOption)
++ {
++ DomItem univ(shared_from_this());
++ switch (fileType) {
++ case DomType::QmlFile:
++ case DomType::JsFile: {
++ const auto &preLoadResult = preload(univ, file, fileType);
++ if (std::holds_alternative<LoadResult>(preLoadResult)) {
++ // universe already has the most recent version of the file
++ return std::get<LoadResult>(preLoadResult);
++ } else {
++ // content of the file needs to be parsed and value inside Universe needs to be updated
++ return load(std::get<ContentWithDate>(preLoadResult), file, fileType, creationOption);
++ }
++ }
++ default:
++ univ.addError(myErrors()
++ .error(tr("Ignoring request to load file %1 of unexpected type %2, "
++ "calling callback immediately")
++ .arg(file.canonicalPath(), domTypeToString(fileType)))
++ .handle());
++ Q_ASSERT(false && "loading non supported file type");
++ return {};
++ }
++ }
++
++ DomUniverse::LoadResult DomUniverse::load(const ContentWithDate &codeWithDate,
++ const FileToLoad &file, DomType fType,
++ DomCreationOption creationOption)
++ {
++ QString canonicalPath = file.canonicalPath();
++
++ DomItem oldValue; // old ExternalItemPair (might be empty, or equal to newValue)
++ DomItem newValue; // current ExternalItemPair
++ DomItem univ = DomItem(shared_from_this());
++
++ if (fType == DomType::QmlFile) {
++ auto qmlFile = parseQmlFile(codeWithDate.content, file, codeWithDate.date, creationOption);
++ return insertOrUpdateExternalItem(std::move(qmlFile));
++ } else if (fType == DomType::JsFile) {
++ auto jsFile = parseJsFile(codeWithDate.content, file, codeWithDate.date);
++ return insertOrUpdateExternalItem(std::move(jsFile));
++ } else {
++ Q_ASSERT(false);
++ }
++ return { std::move(oldValue), std::move(newValue) };
++ }
++
++ /*!
++ \internal
++ This function is somewhat coupled and does the following:
++ 1. If a content of the file is provided it checks whether the item with the same content
++ already exists inside the Universe. If so, returns it as a result of the load
++ 2. If a content is not provided, it first tries to check whether Universe has the most
++ recent item. If yes, it returns it as a result of the load. Otherwise does step 1.
++ */
++ DomUniverse::PreloadResult DomUniverse::preload(const DomItem &univ, const FileToLoad &file,
++ DomType fType) const
++ {
++ QString canonicalPath = file.canonicalPath();
++ ContentWithDate codeWithDate;
++
++ if (file.content().has_value()) {
++ codeWithDate = { file.content()->data, file.content()->date };
++ } else {
++ // When content is empty, Universe attempts to read it from the File.
++ // However if it already has the most recent version of that File it just returns it
++ const auto &curValueItem = getItemIfMostRecent(univ, fType, canonicalPath);
++ if (curValueItem.has_value()) {
++ return LoadResult{ curValueItem.value(), curValueItem.value() };
++ }
++ // otherwise tries to read the content from the path
++ auto readResult = readFileContent(canonicalPath);
++ if (std::holds_alternative<ErrorMessage>(readResult)) {
++ DomItem newValue;
++ newValue.addError(std::move(std::get<ErrorMessage>(readResult)));
++ return LoadResult{ DomItem(), std::move(newValue) }; // read failed, nothing to parse
++ } else {
++ codeWithDate = std::get<ContentWithDate>(readResult);
++ }
++ }
++
++ // Once the code is provided Universe verifies if it already has an up-to-date code
++ const auto &curValueItem = getItemIfHasSameCode(univ, fType, canonicalPath, codeWithDate);
++ if (curValueItem.has_value()) {
++ return LoadResult{ curValueItem.value(), curValueItem.value() };
++ }
++ // otherwise code needs to be parsed
++ return codeWithDate;
++ }
++
++ void DomUniverse::removePath(const QString &path)
++ {
++ QMutexLocker l(mutex());
++ const auto toDelete = [path](const auto &it) {
++ QString p = it.key();
++ return p.startsWith(path) && (p.size() == path.size() || p.at(path.size()) == u'/');
++ };
++ m_qmlFileWithPath.removeIf(toDelete);
++ m_jsFileWithPath.removeIf(toDelete);
++ }
++
++ DomUniverse::ReadResult DomUniverse::readFileContent(const QString &canonicalPath) const
++ {
++ if (canonicalPath.isEmpty()) {
++ return myErrors().error(tr("Non existing path %1").arg(canonicalPath));
++ }
++ QFile file(canonicalPath);
++ QFileInfo fileInfo(canonicalPath);
++ if (fileInfo.isDir()) {
++ return ContentWithDate{ QDir(canonicalPath)
++ .entryList(QDir::NoDotAndDotDot | QDir::Files, QDir::Name)
++ .join(QLatin1Char('\n')),
++ QDateTime::currentDateTimeUtc() };
++ }
++ if (!file.open(QIODevice::ReadOnly)) {
++ return myErrors().error(
++ tr("Error opening path %1: %2 %3")
++ .arg(canonicalPath, QString::number(file.error()), file.errorString()));
++ }
++ auto content = QString::fromUtf8(file.readAll());
++ file.close();
++ return ContentWithDate{ std::move(content), QDateTime::currentDateTimeUtc() };
++ }
++
++ std::shared_ptr<QmlFile> DomUniverse::parseQmlFile(const QString &code, const FileToLoad &file,
++ const QDateTime &contentDate,
++ DomCreationOption creationOption)
++ {
++ auto qmlFile =
++ std::make_shared<QmlFile>(file.canonicalPath(), code, contentDate, 0,
++ creationOption == Extended ? QmlFile::EnableParserRecovery
++ : QmlFile::DisableParserRecovery);
++ std::shared_ptr<DomEnvironment> envPtr;
++ if (auto ptr = file.environment())
++ envPtr = std::move(ptr);
++ else
++ envPtr = std::make_shared<DomEnvironment>(QStringList(),
++ DomEnvironment::Option::NoDependencies,
++ creationOption, shared_from_this());
++ envPtr->addQmlFile(qmlFile);
++ DomItem env(envPtr);
++ if (qmlFile->isValid()) {
++ // do not call populateQmlFile twice on lazy qml files if the importer already does it!
++ if (creationOption != DomCreationOption::Extended)
++ envPtr->populateFromQmlFile(MutableDomItem(env.copy(qmlFile)));
++ } else {
++ QString errs;
++ DomItem qmlFileObj = env.copy(qmlFile);
++ qmlFile->iterateErrors(qmlFileObj, [&errs](const DomItem &, const ErrorMessage &m) {
++ errs += m.toString();
++ errs += u"\n";
++ return true;
++ });
++ qCWarning(domLog).noquote().nospace()
++ << "Parsed invalid file " << file.canonicalPath() << errs;
++ }
++ return qmlFile;
++ }
++
++ std::shared_ptr<JsFile> DomUniverse::parseJsFile(const QString &code, const FileToLoad &file,
++ const QDateTime &contentDate)
++ {
++ // WATCH OUT!
++ // DOM construction for plain JS files is not yet supported
++ // Only parsing of the file
++ // and adding ExternalItem to the Environment will happen here
++ auto jsFile = std::make_shared<JsFile>(file.canonicalPath(), code, contentDate);
++ std::shared_ptr<DomEnvironment> envPtr;
++ if (auto ptr = file.environment())
++ envPtr = std::move(ptr);
++ else
++ envPtr = std::make_shared<DomEnvironment>(QStringList(),
++ DomEnvironment::Option::NoDependencies,
++ DomCreationOption::Default, shared_from_this());
++ envPtr->addJsFile(jsFile);
++ DomItem env(envPtr);
++ if (!jsFile->isValid()) {
++ QString errs;
++ DomItem qmlFileObj = env.copy(jsFile);
++ jsFile->iterateErrors(qmlFileObj, [&errs](const DomItem &, const ErrorMessage &m) {
++ errs += m.toString();
++ errs += u"\n";
++ return true;
++ });
++ qCWarning(domLog).noquote().nospace()
++ << "Parsed invalid file " << file.canonicalPath() << errs;
++ }
++ return jsFile;
++ }
++
++ /*!
++ \internal
++ Queries the corresponding path map attempting to get the value
++ *WARNING* Usage of this function should be protected by the read lock
++ */
++ std::shared_ptr<ExternalItemPairBase> DomUniverse::getPathValueOrNull(DomType fType,
++ const QString &path) const
++ {
++ switch (fType) {
++ case DomType::QmlFile:
++ return m_qmlFileWithPath.value(path);
++ case DomType::JsFile:
++ return m_jsFileWithPath.value(path);
++ default:
++ Q_ASSERT(false);
++ }
++ return nullptr;
++ }
++
++ std::optional<DomItem> DomUniverse::getItemIfMostRecent(const DomItem &univ, DomType fType,
++ const QString &canonicalPath) const
++ {
++ QFileInfo fInfo(canonicalPath);
++ bool valueItemIsMostRecent = false;
++ std::shared_ptr<ExternalItemPairBase> value = nullptr;
++ {
++ // Mutex is to sync access to the Value and Value->CurrentItem, which can be modified
++ // through updateEnty method and currentItem->refreshedDataAt
++ QMutexLocker l(mutex());
++ value = getPathValueOrNull(fType, canonicalPath);
++ valueItemIsMostRecent = valueHasMostRecentItem(value.get(), fInfo.lastModified());
++ }
++ if (valueItemIsMostRecent) {
++ return univ.copy(value);
++ }
++ return std::nullopt;
++ }
++
++ std::optional<DomItem> DomUniverse::getItemIfHasSameCode(const DomItem &univ, DomType fType,
++ const QString &canonicalPath,
++ const ContentWithDate &codeWithDate) const
++ {
++ std::shared_ptr<ExternalItemPairBase> value = nullptr;
++ bool valueItemHasSameCode = false;
++ {
++ // Mutex is to sync access to the Value and Value->CurrentItem, which can be modified
++ // through updateEnty method and currentItem->refreshedDataAt
++ QMutexLocker l(mutex());
++ value = getPathValueOrNull(fType, canonicalPath);
++ if (valueHasSameContent(value.get(), codeWithDate.content)) {
++ valueItemHasSameCode = true;
++ if (value->currentItem()->lastDataUpdateAt() < codeWithDate.date)
++ value->currentItem()->refreshedDataAt(codeWithDate.date);
++ }
++ }
++ if (valueItemHasSameCode) {
++ return univ.copy(value);
++ }
++ return std::nullopt;
++ }
++
++ /*!
++ \internal
++ Checks if value has current Item and if it was not modified since last seen
++ *WARNING* Usage of this function should be protected by the read lock
++ */
++ bool DomUniverse::valueHasMostRecentItem(const ExternalItemPairBase *value,
++ const QDateTime &lastModified)
++ {
++ if (!value || !value->currentItem()) {
++ return false;
++ }
++ return lastModified < value->currentItem()->lastDataUpdateAt();
++ }
++
++ /*!
++ \internal
++ Checks if value has current Item and if it has same content
++ *WARNING* Usage of this function should be protected by the read lock
++ */
++ bool DomUniverse::valueHasSameContent(const ExternalItemPairBase *value, const QString &content)
++ {
++ if (!value || !value->currentItem()) {
++ return false;
++ }
++ QString curContent = value->currentItem()->code();
++ return !curContent.isNull() && curContent == content;
++ }
++
++ std::shared_ptr<OwningItem> LoadInfo::doCopy(const DomItem &self) const
++ {
++ auto res = std::make_shared<LoadInfo>(*this);
++ if (res->status() != Status::Done) {
++ res->addErrorLocal(DomEnvironment::myErrors().warning(
++ u"This is a copy of a LoadInfo still in progress, artificially ending it, if you "
++ u"use this you will *not* resume loading"_sv));
++ DomEnvironment::myErrors()
++ .warning([&self](const Sink &sink) {
++ sink(u"Copying an in progress LoadInfo, which is most likely an error (");
++ self.dump(sink);
++ sink(u")");
++ })
++ .handle();
++ QMutexLocker l(res->mutex());
++ res->m_status = Status::Done;
++ res->m_toDo.clear();
++ res->m_inProgress.clear();
++ res->m_endCallbacks.clear();
++ }
++ return res;
++ }
++
++ Path LoadInfo::canonicalPath(const DomItem &) const
++ {
++ return Path::fromRoot(PathRoot::Env).withField(Fields::loadInfo).withKey(elementCanonicalPath().toString());
++ }
++
++ bool LoadInfo::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
++ {
++ bool cont = OwningItem::iterateDirectSubpaths(self, visitor);
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::status), int(status()));
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::nLoaded), nLoaded());
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::elementCanonicalPath),
++ elementCanonicalPath().toString());
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::nNotdone), nNotDone());
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::nCallbacks), nCallbacks());
++ return cont;
++ }
++
++ void LoadInfo::addEndCallback(const DomItem &self,
++ std::function<void(Path, const DomItem &, const DomItem &)> callback)
++ {
++ if (!callback)
++ return;
++ {
++ QMutexLocker l(mutex());
++ switch (m_status) {
++ case Status::NotStarted:
++ case Status::Starting:
++ case Status::InProgress:
++ case Status::CallingCallbacks:
++ m_endCallbacks.append(callback);
++ return;
++ case Status::Done:
++ break;
++ }
++ }
++ Path p = elementCanonicalPath();
++ DomItem el = self.path(p);
++ callback(p, el, el);
++ }
++
++ void LoadInfo::advanceLoad(const DomItem &self)
++ {
++ Status myStatus;
++ Dependency dep;
++ bool depValid = false;
++ {
++ QMutexLocker l(mutex());
++ myStatus = m_status;
++ switch (myStatus) {
++ case Status::NotStarted:
++ m_status = Status::Starting;
++ break;
++ case Status::Starting:
++ case Status::InProgress:
++ if (!m_toDo.isEmpty()) {
++ dep = m_toDo.dequeue();
++ m_inProgress.append(dep);
++ depValid = true;
++ }
++ break;
++ case Status::CallingCallbacks:
++ case Status::Done:
++ break;
++ }
++ }
++ switch (myStatus) {
++ case Status::NotStarted:
++ refreshedDataAt(QDateTime::currentDateTimeUtc());
++ doAddDependencies(self);
++ refreshedDataAt(QDateTime::currentDateTimeUtc());
++ {
++ QMutexLocker l(mutex());
++ Q_ASSERT(m_status == Status::Starting);
++ if (m_toDo.isEmpty() && m_inProgress.isEmpty())
++ myStatus = m_status = Status::CallingCallbacks;
++ else
++ myStatus = m_status = Status::InProgress;
++ }
++ if (myStatus == Status::CallingCallbacks)
++ execEnd(self);
++ break;
++ case Status::Starting:
++ case Status::InProgress:
++ if (depValid) {
++ refreshedDataAt(QDateTime::currentDateTimeUtc());
++ auto envPtr = self.environment().ownerAs<DomEnvironment>();
++ Q_ASSERT(envPtr && "missing environment");
++ if (!dep.uri.isEmpty()) {
++ Q_ASSERT(dep.filePath.isEmpty() && "dependency with both uri and file");
++ } else if (!dep.filePath.isEmpty()) {
++ envPtr->loadFile(
++ FileToLoad::fromFileSystem(envPtr, dep.filePath),
++ [this, copiedSelf = self, dep](Path, const DomItem &, const DomItem &) {
++ // Need to explicitly copy self here since we might store this and
++ // call it later.
++ finishedLoadingDep(copiedSelf, dep);
++ },
++ dep.fileType, self.errorHandler());
++ } else {
++ Q_ASSERT(false && "dependency without uri and filePath");
++ }
++ } else {
++ addErrorLocal(DomEnvironment::myErrors().error(
++ tr("advanceLoad called but found no work, which should never happen")));
++ }
++ break;
++ case Status::CallingCallbacks:
++ case Status::Done:
++ addErrorLocal(DomEnvironment::myErrors().error(tr(
++ "advanceLoad called after work should have been done, which should never happen")));
++ break;
++ }
++ }
++
++ void LoadInfo::finishedLoadingDep(const DomItem &self, const Dependency &d)
++ {
++ bool didRemove = false;
++ bool unexpectedState = false;
++ bool doEnd = false;
++ {
++ QMutexLocker l(mutex());
++ didRemove = m_inProgress.removeOne(d);
++ switch (m_status) {
++ case Status::NotStarted:
++ case Status::CallingCallbacks:
++ case Status::Done:
++ unexpectedState = true;
++ break;
++ case Status::Starting:
++ break;
++ case Status::InProgress:
++ if (m_toDo.isEmpty() && m_inProgress.isEmpty()) {
++ m_status = Status::CallingCallbacks;
++ doEnd = true;
++ }
++ break;
++ }
++ }
++ if (!didRemove) {
++ addErrorLocal(DomEnvironment::myErrors().error([&self](const Sink &sink) {
++ sink(u"LoadInfo::finishedLoadingDep did not find its dependency in those inProgress "
++ u"()");
++ self.dump(sink);
++ sink(u")");
++ }));
++ Q_ASSERT(false
++ && "LoadInfo::finishedLoadingDep did not find its dependency in those inProgress");
++ }
++ if (unexpectedState) {
++ addErrorLocal(DomEnvironment::myErrors().error([&self](const Sink &sink) {
++ sink(u"LoadInfo::finishedLoadingDep found an unexpected state (");
++ self.dump(sink);
++ sink(u")");
++ }));
++ Q_ASSERT(false && "LoadInfo::finishedLoadingDep did find an unexpected state");
++ }
++ if (doEnd)
++ execEnd(self);
++ }
++
++ void LoadInfo::execEnd(const DomItem &self)
++ {
++ QList<std::function<void(Path, const DomItem &, const DomItem &)>> endCallbacks;
++ bool unexpectedState = false;
++ {
++ QMutexLocker l(mutex());
++ unexpectedState = m_status != Status::CallingCallbacks;
++ endCallbacks = m_endCallbacks;
++ m_endCallbacks.clear();
++ }
++ Q_ASSERT(!unexpectedState && "LoadInfo::execEnd found an unexpected state");
++ Path p = elementCanonicalPath();
++ DomItem el = self.path(p);
++ {
++ auto cleanup = qScopeGuard([this, p, &el] {
++ QList<std::function<void(Path, const DomItem &, const DomItem &)>> otherCallbacks;
++ bool unexpectedState2 = false;
++ {
++ QMutexLocker l(mutex());
++ unexpectedState2 = m_status != Status::CallingCallbacks;
++ m_status = Status::Done;
++ otherCallbacks = m_endCallbacks;
++ m_endCallbacks.clear();
++ }
++ Q_ASSERT(!unexpectedState2 && "LoadInfo::execEnd found an unexpected state");
++ for (auto const &cb : otherCallbacks) {
++ if (cb)
++ cb(p, el, el);
++ }
++ });
++ for (auto const &cb : endCallbacks) {
++ if (cb)
++ cb(p, el, el);
++ }
++ }
++ }
++
++ void LoadInfo::doAddDependencies(const DomItem &self)
++ {
++ if (!elementCanonicalPath()) {
++ DomEnvironment::myErrors()
++ .error(tr("Uninitialized LoadInfo %1").arg(self.canonicalPath().toString()))
++ .handle(nullptr);
++ Q_ASSERT(false);
++ return;
++ }
++ // sychronous add of all dependencies
++ DomItem el = self.path(elementCanonicalPath());
++ if (el.internalKind() == DomType::ExternalItemInfo) {
++ DomItem currentFile = el.field(Fields::currentItem);
++ QString currentFilePath = currentFile.canonicalFilePath();
++ // do not mess with QmlFile's lazy-loading
++ if (currentFile.internalKind() != DomType::QmlFile) {
++ DomItem currentQmlFiles = currentFile.field(Fields::qmlFiles);
++ currentQmlFiles.visitKeys([this, &self](const QString &, const DomItem &els) {
++ return els.visitIndexes([this, &self](const DomItem &el) {
++ if (const Reference *ref = el.as<Reference>()) {
++ Path canonicalPath = ref->referredObjectPath[2];
++ if (canonicalPath && !canonicalPath.headName().isEmpty())
++ addDependency(self,
++ Dependency{ QString(), Version(),
++ canonicalPath.headName(), DomType::QmlFile });
++ }
++ return true;
++ });
++ });
++ }
++ } else if (!el) {
++ self.addError(DomEnvironment::myErrors().error(
++ tr("Ignoring dependencies for empty (invalid) type %1")
++ .arg(domTypeToString(el.internalKind()))));
++ } else {
++ self.addError(
++ DomEnvironment::myErrors().error(tr("dependencies of %1 (%2) not yet implemented")
++ .arg(domTypeToString(el.internalKind()),
++ elementCanonicalPath().toString())));
++ }
++ }
++
++ void LoadInfo::addDependency(const DomItem &self, const Dependency &dep)
++ {
++ bool unexpectedState = false;
++ {
++ QMutexLocker l(mutex());
++ unexpectedState = m_status != Status::Starting;
++ m_toDo.enqueue(dep);
++ }
++ Q_ASSERT(!unexpectedState && "LoadInfo::addDependency found an unexpected state");
++ DomItem env = self.environment();
++ env.ownerAs<DomEnvironment>()->addWorkForLoadInfo(elementCanonicalPath());
++ }
++
++ /*!
++ \class QQmlJS::Dom::DomEnvironment
++
++ \brief Represents a consistent set of types organized in modules, it is the top level of the DOM
++
++ The DomEnvironment keeps a pointer m_lastValidBase to the last used valid DomEnvironment in the
++ commitToBase() method. This allows the qqmldomastcreator to commit lazily loaded dependencies to the
++ valid environment used by qmlls.
++ */
++
++ ErrorGroups DomEnvironment::myErrors()
++ {
++ static ErrorGroups res = {{NewErrorGroup("Dom")}};
++ return res;
++ }
++
++ DomType DomEnvironment::kind() const
++ {
++ return kindValue;
++ }
++
++ Path DomEnvironment::canonicalPath() const
++ {
++ return Path::fromRoot(u"env");
++ }
++
++ bool DomEnvironment::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
++ {
++ bool cont = true;
++ cont = cont && DomTop::iterateDirectSubpaths(self, visitor);
++ DomItem univ = universe();
++ cont = cont && visitor(PathEls::Field(Fields::universe), [this]() { return universe(); });
++ cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::options), int(options()));
++ cont = cont && visitor(PathEls::Field(Fields::base), [this]() { return base(); });
++ cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::loadPaths, [this]() {
++ return loadPaths();
++ });
++ cont = cont && visitor(PathEls::Field(Fields::qmlFileWithPath), [this, &self]() {
++ return self.subMapItem(Map(
++ Path::fromField(Fields::qmlFileWithPath),
++ [&self, this](const DomItem &map, const QString &key) {
++ return map.copy(qmlFileWithPath(self, key));
++ },
++ [&self, this](const DomItem &) { return qmlFilePaths(self); },
++ QLatin1String("QmlFile")));
++ });
++ cont = cont && visitor(PathEls::Field(Fields::jsFileWithPath), [this, &self]() {
++ return self.subMapItem(Map(
++ Path::fromField(Fields::jsFileWithPath),
++ [this](const DomItem &map, const QString &key) {
++ DomItem mapOw(map.owner());
++ return map.copy(jsFileWithPath(mapOw, key));
++ },
++ [this](const DomItem &map) {
++ DomItem mapOw = map.owner();
++ return jsFilePaths(mapOw);
++ },
++ QLatin1String("JsFile")));
++ });
++ bool loadedLoadInfo = false;
++ QQueue<Path> loadsWithWork;
++ QQueue<Path> inProgress;
++ int nAllLoadedCallbacks;
++ auto ensureInfo = [&]() {
++ if (!loadedLoadInfo) {
++ QMutexLocker l(mutex());
++ loadedLoadInfo = true;
++ loadsWithWork = m_loadsWithWork;
++ inProgress = m_inProgress;
++ nAllLoadedCallbacks = m_allLoadedCallback.size();
++ }
++ };
++ cont = cont && visitor(
++ PathEls::Field(Fields::loadsWithWork), [&ensureInfo, &self, &loadsWithWork]() {
++ ensureInfo();
++ return self.subListItem(List(
++ Path::fromField(Fields::loadsWithWork),
++ [loadsWithWork](const DomItem &list, index_type i) {
++ if (i >= 0 && i < loadsWithWork.size())
++ return list.subDataItem(PathEls::Index(i),
++ loadsWithWork.at(i).toString());
++ else
++ return DomItem();
++ },
++ [loadsWithWork](const DomItem &) {
++ return index_type(loadsWithWork.size());
++ },
++ nullptr, QLatin1String("Path")));
++ });
++ cont = cont && visitor(PathEls::Field(Fields::inProgress), [&self, &ensureInfo, &inProgress]() {
++ ensureInfo();
++ return self.subListItem(List(
++ Path::fromField(Fields::inProgress),
++ [inProgress](const DomItem &list, index_type i) {
++ if (i >= 0 && i < inProgress.size())
++ return list.subDataItem(PathEls::Index(i),
++ inProgress.at(i).toString());
++ else
++ return DomItem();
++ },
++ [inProgress](const DomItem &) { return index_type(inProgress.size()); },
++ nullptr, QLatin1String("Path")));
++ });
++ cont = cont && visitor(PathEls::Field(Fields::loadInfo), [&self, this]() {
++ return self.subMapItem(Map(
++ Path::fromField(Fields::loadInfo),
++ [this](const DomItem &map, const QString &pStr) {
++ bool hasErrors = false;
++ Path p = Path::fromString(pStr, [&hasErrors](const ErrorMessage &m) {
++ switch (m.level) {
++ case ErrorLevel::Debug:
++ case ErrorLevel::Info:
++ break;
++ case ErrorLevel::Warning:
++ case ErrorLevel::Error:
++ case ErrorLevel::Fatal:
++ hasErrors = true;
++ break;
++ }
++ });
++ if (!hasErrors)
++ return map.copy(loadInfo(p));
++ return DomItem();
++ },
++ [this](const DomItem &) {
++ QSet<QString> res;
++ const auto infoPaths = loadInfoPaths();
++ for (const Path &p : infoPaths)
++ res.insert(p.toString());
++ return res;
++ },
++ QLatin1String("LoadInfo")));
++ });
++ cont = cont && self.invokeVisitorOnField(visitor, Fields::imports, m_implicitImports);
++ cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::nAllLoadedCallbacks,
++ [&nAllLoadedCallbacks, &ensureInfo]() {
++ ensureInfo();
++ return nAllLoadedCallbacks;
++ });
++ return cont;
++ }
++
++ DomItem DomEnvironment::field(const DomItem &self, QStringView name) const
++ {
++ return DomTop::field(self, name);
++ }
++
++ std::shared_ptr<DomEnvironment> DomEnvironment::makeCopy(const DomItem &self) const
++ {
++ return std::static_pointer_cast<DomEnvironment>(doCopy(self));
++ }
++
++ std::shared_ptr<OwningItem> DomEnvironment::doCopy(const DomItem &) const
++ {
++ shared_ptr<DomEnvironment> res;
++ if (m_base)
++ res = std::make_shared<DomEnvironment>(m_base, m_loadPaths, m_options, m_domCreationOption);
++ else
++ res = std::make_shared<DomEnvironment>(m_loadPaths, m_options, m_domCreationOption,
++ m_universe);
++ return res;
++ }
++
++ bool DomEnvironment::hasFile(const QString &filePath) const
++ {
++ return m_qmlFileWithPath.contains(filePath);
++ }
++ void DomEnvironment::loadFile(const FileToLoad &file, const Callback &callback,
++ std::optional<DomType> fileType, const ErrorHandler &h)
++ {
++ if (options() & DomEnvironment::Option::NoDependencies)
++ loadFile(file, callback, DomTop::Callback(), fileType, h);
++ else {
++ // When the file is required to be loaded with dependencies, those dependencies
++ // will be added to the "pending" queue through envCallbackForFile
++ // then those should not be forgotten to be loaded.
++ loadFile(file, DomTop::Callback(), callback, fileType, h);
++ }
++ }
++
++ /*!
++ \internal
++ Depending on the options, the function will be called either with loadCallback OR endCallback
++
++ Before loading the file, envCallbackForFile will be created and passed as an argument to
++ universe().loadFile(...).
++ This is a callback which will be called after the load of the file is finished. More
++ specifically when File is required to be loaded without Dependencies only loadCallback is being
++ used. Otherwise, the callback is passed as endCallback. What endCallback means is that this
++ callback will be called only at the very end, once all necessary dependencies are being loaded.
++ Management and handing of this is happening through the m_loadsWithWork.
++ */
++ // TODO(QTBUG-119550) refactor this
++ void DomEnvironment::loadFile(const FileToLoad &_file, const Callback &loadCallback,
++ const Callback &endCallback, std::optional<DomType> fileType,
++ const ErrorHandler &h)
++ {
++ DomItem self(shared_from_this());
++ const DomType fType =
++ (bool(fileType) ? (*fileType) : fileTypeForPath(self, _file.logicalPath()));
++
++ FileToLoad file {_file};
++
++ if (domCreationOption() == DomCreationOption::Extended) {
++ // use source folders when loading qml files and build folders otherwise
++ if (fType == DomType::QmlFile) {
++ file.setCanonicalPath(QQmlJSUtils::qmlSourcePathFromBuildPath(
++ semanticAnalysis().m_mapper.get(), file.canonicalPath()));
++ file.setLogicalPath(file.logicalPath());
++ }
++ }
++
++ if (file.canonicalPath().isEmpty()) {
++ if (!file.content() || file.content()->data.isNull()) {
++ // file's content inavailable and no path to retrieve it
++ myErrors()
++ .error(tr("Non existing path to load: '%1'").arg(file.logicalPath()))
++ .handle(h);
++ if (loadCallback)
++ loadCallback(Path(), DomItem::empty, DomItem::empty);
++ if (endCallback)
++ addAllLoadedCallback(self, [endCallback](Path, const DomItem &, const DomItem &) {
++ endCallback(Path(), DomItem::empty, DomItem::empty);
++ });
++ return;
++ } else {
++ // fallback: path invalid but file's content is already available.
++ file.canonicalPath() = file.logicalPath();
++ }
++ }
++
++ shared_ptr<ExternalItemInfoBase> oldValue, newValue;
++ switch (fType) {
++ case DomType::QmlFile: {
++ const auto &fetchResult = fetchFileFromEnvs<QmlFile>(file);
++ oldValue = fetchResult.first;
++ newValue = fetchResult.second;
++ if (!newValue) {
++ const auto &loadRes = universe()->loadFile(file, fType, m_domCreationOption);
++ addExternalItemInfo<QmlFile>(loadRes.currentItem, loadCallback, endCallback);
++ return;
++ }
++ } break;
++ case DomType::JsFile: {
++ const auto &loadRes = universe()->loadFile(file, fType, m_domCreationOption);
++ addExternalItemInfo<JsFile>(loadRes.currentItem, loadCallback, endCallback);
++ return;
++ } break;
++ default: {
++ myErrors().error(tr("Unexpected file to load: '%1'").arg(file.canonicalPath())).handle(h);
++ if (loadCallback)
++ loadCallback(self.canonicalPath(), DomItem::empty, DomItem::empty);
++ if (endCallback)
++ endCallback(self.canonicalPath(), DomItem::empty, DomItem::empty);
++ return;
++ } break;
++ }
++ Path p = self.copy(newValue).canonicalPath();
++ std::shared_ptr<LoadInfo> lInfo = loadInfo(p);
++ if (lInfo) {
++ if (loadCallback) {
++ DomItem oldValueObj = self.copy(oldValue);
++ DomItem newValueObj = self.copy(newValue);
++ loadCallback(p, oldValueObj, newValueObj);
++ }
++ } else {
++ self.addError(myErrors().error(tr("missing load info in ")));
++ if (loadCallback)
++ loadCallback(self.canonicalPath(), DomItem::empty, DomItem::empty);
++ }
++ if (endCallback)
++ addAllLoadedCallback(self, [p = std::move(p), endCallback](
++ const Path &, const DomItem &, const DomItem &env) {
++ DomItem el = env.path(p);
++ endCallback(p, el, el);
++ });
++ }
++
++ void DomEnvironment::removePath(const QString &path)
++ {
++ QMutexLocker l(mutex());
++ auto toDelete = [path](auto it) {
++ QString p = it.key();
++ return p.startsWith(path) && (p.size() == path.size() || p.at(path.size()) == u'/');
++ };
++ m_qmlFileWithPath.removeIf(toDelete);
++ m_jsFileWithPath.removeIf(toDelete);
++ }
++
++ shared_ptr<DomUniverse> DomEnvironment::universe() const {
++ if (m_universe)
++ return m_universe;
++ else if (m_base)
++ return m_base->universe();
++ else
++ return {};
++ }
++
++ template<typename T>
++ QSet<QString> DomEnvironment::getStrings(function_ref<QSet<QString>()> getBase,
++ const QMap<QString, T> &selfMap, EnvLookup options) const
++ {
++ QSet<QString> res;
++ if (options != EnvLookup::NoBase && m_base) {
++ if (m_base)
++ res = getBase();
++ }
++ if (options != EnvLookup::BaseOnly) {
++ QMap<QString, T> map;
++ {
++ QMutexLocker l(mutex());
++ map = selfMap;
++ }
++ auto it = map.keyBegin();
++ auto end = map.keyEnd();
++ while (it != end) {
++ res += *it;
++ ++it;
++ }
++ }
++ return res;
++ }
++
++ std::shared_ptr<ExternalItemInfo<QmlFile>>
++ DomEnvironment::qmlFileWithPath(const DomItem &, const QString &path, EnvLookup options) const
++ {
++ return lookup<QmlFile>(path, options);
++ }
++
++ QSet<QString> DomEnvironment::qmlFilePaths(const DomItem &, EnvLookup lookup) const
++ {
++ return getStrings<std::shared_ptr<ExternalItemInfo<QmlFile>>>(
++ [this] {
++ DomItem baseObj(m_base);
++ return m_base->qmlFilePaths(baseObj, EnvLookup::Normal);
++ },
++ m_qmlFileWithPath, lookup);
++ }
++
++ std::shared_ptr<ExternalItemInfo<JsFile>>
++ DomEnvironment::jsFileWithPath(const DomItem &, const QString &path, EnvLookup options) const
++ {
++ return lookup<JsFile>(path, options);
++ }
++
++ QSet<QString> DomEnvironment::jsFilePaths(const DomItem &, EnvLookup lookup) const
++ {
++ return getStrings<std::shared_ptr<ExternalItemInfo<JsFile>>>(
++ [this] {
++ DomItem baseObj(m_base);
++ return m_base->jsFilePaths(baseObj, EnvLookup::Normal);
++ },
++ m_jsFileWithPath, lookup);
++ }
++
++ /*!
++ \internal
++ Depending on the creation options, this function adds LoadInfo of the provided path
++ */
++ void DomEnvironment::addDependenciesToLoad(const Path &path)
++ {
++ if (options() & Option::NoDependencies) {
++ return;
++ }
++ Q_ASSERT(path);
++ const auto loadInfo = std::make_shared<LoadInfo>(path);
++ return addLoadInfo(DomItem(shared_from_this()), loadInfo);
++ }
++
++ /*!
++ \internal
++ Enqueues path to the m_loadsWithWork (queue of the pending "load" jobs).
++ In simpler words, schedule the load of the dependencies of the path from loadInfo.
++ */
++ void DomEnvironment::addLoadInfo(const DomItem &self, const std::shared_ptr<LoadInfo> &loadInfo)
++ {
++ if (!loadInfo)
++ return;
++ Path p = loadInfo->elementCanonicalPath();
++ bool addWork = loadInfo->status() != LoadInfo::Status::Done;
++ std::shared_ptr<LoadInfo> oldVal;
++ {
++ QMutexLocker l(mutex());
++ oldVal = m_loadInfos.value(p);
++ m_loadInfos.insert(p, loadInfo);
++ if (addWork)
++ m_loadsWithWork.enqueue(p);
++ }
++ if (oldVal && oldVal->status() != LoadInfo::Status::Done) {
++ self.addError(myErrors()
++ .error(tr("addLoadinfo replaces unfinished load info for %1")
++ .arg(p.toString()))
++ .handle());
++ }
++ }
++
++ std::shared_ptr<LoadInfo> DomEnvironment::loadInfo(const Path &path) const
++ {
++ QMutexLocker l(mutex());
++ return m_loadInfos.value(path);
++ }
++
++ QHash<Path, std::shared_ptr<LoadInfo>> DomEnvironment::loadInfos() const
++ {
++ QMutexLocker l(mutex());
++ return m_loadInfos;
++ }
++
++ QList<Path> DomEnvironment::loadInfoPaths() const
++ {
++ auto lInfos = loadInfos();
++ return lInfos.keys();
++ }
++
++ DomEnvironment::DomEnvironment(const QStringList &loadPaths, Options options,
++ DomCreationOption domCreationOption,
++ const shared_ptr<DomUniverse> &universe)
++ : m_options(options),
++ m_universe(DomUniverse::guaranteeUniverse(universe)),
++ m_loadPaths(loadPaths),
++ m_implicitImports(defaultImplicitImports()),
++ m_domCreationOption(domCreationOption)
++
++ {
++ }
++
++ /*!
++ \internal
++ Do not call this method inside of DomEnvironment's constructor! It requires weak_from_this() that
++ only works after the constructor call finished.
++ */
++ DomEnvironment::SemanticAnalysis DomEnvironment::semanticAnalysis()
++ {
++ QMutexLocker l(mutex());
++ return semanticAnalysisUnlocked();
++ }
++
++ DomEnvironment::SemanticAnalysis DomEnvironment::prepareSemanticAnalysisForFileLoading()
++ {
++ QMutexLocker guard(mutex());
++ auto result = semanticAnalysisUnlocked();
++ result.updateLoadPaths(m_loadPaths);
++ result.setResourceFiles(m_resourcePaths);
++ return result;
++ }
++
++ DomEnvironment::SemanticAnalysis DomEnvironment::semanticAnalysisUnlocked()
++ {
++ // QTBUG-124799: do not create a SemanticAnalysis in a temporary DomEnvironment, and use the one
++ // from the base environment instead.
++ if (m_base)
++ return m_base->semanticAnalysis();
++
++ if (m_semanticAnalysis)
++ return *m_semanticAnalysis;
++
++ Q_ASSERT(domCreationOption() == DomCreationOption::Extended);
++ m_semanticAnalysis = SemanticAnalysis(m_loadPaths);
++ return *m_semanticAnalysis;
++ }
++
++ DomEnvironment::SemanticAnalysis::SemanticAnalysis(const QStringList &loadPaths)
++ : m_mapper(std::make_shared<QQmlJSResourceFileMapper>(
++ QQmlJSUtils::resourceFilesFromBuildFolders(loadPaths))),
++ m_importer(std::make_shared<QQmlJSImporter>(loadPaths, m_mapper.get(),
++ QQmlJSImporterFlags{} | UseOptionalImports
++ | TolerateFileSelectors
++ | PreferQmlFilesFromSourceFolder))
++ {
++ }
++
++ /*!
++ \internal
++
++ Sets the new load paths in the importer.
++
++ This affects all copies of SemanticAnalysis that use the same QQmlJSImporter and QQmlJSMapper
++ pointers.
++ */
++ void DomEnvironment::SemanticAnalysis::updateLoadPaths(const QStringList &loadPaths)
++ {
++ if (loadPaths == m_importer->importPaths())
++ return;
++
++ m_importer->setImportPaths(loadPaths);
++ }
++
++ void DomEnvironment::SemanticAnalysis::setResourceFiles(const QStringList &qrcFiles)
++ {
++ if (qrcFiles == m_resourceFiles)
++ return;
++ m_resourceFiles = qrcFiles;
++ *m_mapper = QQmlJSResourceFileMapper(qrcFiles);
++ }
++
++ std::shared_ptr<DomEnvironment> DomEnvironment::create(const QStringList &loadPaths,
++ Options options,
++ DomCreationOption domCreationOption,
++ const DomItem &universe)
++ {
++ std::shared_ptr<DomUniverse> universePtr = universe.ownerAs<DomUniverse>();
++ return std::make_shared<DomEnvironment>(loadPaths, options, domCreationOption, universePtr);
++ }
++
++ DomEnvironment::DomEnvironment(const shared_ptr<DomEnvironment> &parent,
++ const QStringList &loadPaths, Options options,
++ DomCreationOption domCreationOption)
++ : m_options(options),
++ m_base(parent),
++ m_loadPaths(loadPaths),
++ m_implicitImports(defaultImplicitImports()),
++ m_domCreationOption(domCreationOption)
++ {
++ }
++
++ void DomEnvironment::addQmlFile(const std::shared_ptr<QmlFile> &file, AddOption options)
++ {
++ addExternalItem(file, file->canonicalFilePath(), options);
++ if (domCreationOption() == DomCreationOption::Extended) {
++ QQmlJSScope::Ptr handle =
++ semanticAnalysis().m_importer->importFile(file->canonicalFilePath());
++
++ // force reset the outdated qqmljsscope in case it was already populated
++ file->setHandleForPopulation(handle);
++ resetFactory(handle, semanticAnalysis().m_importer.get(),
++ TypeReader{ weak_from_this(), m_loadPaths });
++ }
++ }
++
++
++ void DomEnvironment::addJsFile(const std::shared_ptr<JsFile> &file, AddOption options)
++ {
++ addExternalItem(file, file->canonicalFilePath(), options);
++ }
++
++ void DomEnvironment::TypeReader::operator()(QQmlJSImporter *importer, const QString &filePath,
++ const QSharedPointer<QQmlJSScope> &scopeToPopulate)
++ {
++ Q_UNUSED(importer);
++ Q_UNUSED(scopeToPopulate);
++
++ std::shared_ptr<DomEnvironment> envPtr = m_env.lock();
++ // populate QML File if from implicit import directory
++ // use the version in DomEnvironment and do *not* load from disk.
++ auto it = envPtr->m_qmlFileWithPath.constFind(filePath);
++ if (it == envPtr->m_qmlFileWithPath.constEnd()) {
++ qCDebug(domLog) << "Import visitor tried to lazily load file \"" << filePath
++ << "\", but that file was not found in the DomEnvironment. Was this "
++ "file not discovered by the Dom's dependency loading mechanism?";
++ return;
++ }
++ const DomItem qmlFile = it.value()->currentItem(DomItem(envPtr));
++
++ // workaround for QTBUG-137705 while waiting for qmlls to use separate DomEnvironments for files
++ // requiring different importpaths (QTBUG-134308).
++ const QStringList oldImportPaths = envPtr->loadPaths();
++ envPtr->setLoadPaths(m_importPaths);
++ envPtr->populateFromQmlFile(MutableDomItem(qmlFile));
++ envPtr->setLoadPaths(oldImportPaths);
++ }
++
++ bool DomEnvironment::commitToBase(const DomItem &, const shared_ptr<DomEnvironment> &validEnvPtr)
++ {
++ if (!base())
++ return false;
++ QMap<QString, std::shared_ptr<ExternalItemInfo<QmlFile>>> my_qmlFileWithPath;
++ QMap<QString, std::shared_ptr<ExternalItemInfo<JsFile>>> my_jsFileWithPath;
++ QHash<Path, std::shared_ptr<LoadInfo>> my_loadInfos;
++ std::optional<SemanticAnalysis> my_semanticAnalysis;
++ {
++ QMutexLocker l(mutex());
++ my_qmlFileWithPath = m_qmlFileWithPath;
++ my_jsFileWithPath = m_jsFileWithPath;
++ my_loadInfos = m_loadInfos;
++ my_semanticAnalysis = semanticAnalysisUnlocked();
++ }
++ {
++ QMutexLocker lBase(base()->mutex()); // be more careful about makeCopy calls with lock?
++ m_base->m_semanticAnalysis = my_semanticAnalysis;
++ m_base->m_qmlFileWithPath.insert(my_qmlFileWithPath);
++ m_base->m_jsFileWithPath.insert(my_jsFileWithPath);
++ m_base->m_loadInfos.insert(my_loadInfos);
++ }
++ if (validEnvPtr)
++ m_lastValidBase = validEnvPtr;
++ if (m_lastValidBase) {
++ QMutexLocker lValid(
++ m_lastValidBase->mutex()); // be more careful about makeCopy calls with lock?
++ m_lastValidBase->m_semanticAnalysis = std::move(my_semanticAnalysis);
++ for (auto it = my_qmlFileWithPath.cbegin(), end = my_qmlFileWithPath.cend(); it != end;
++ ++it) {
++ if (it.value() && it.value()->current && it.value()->current->isValid())
++ m_lastValidBase->m_qmlFileWithPath.insert(it.key(), it.value());
++ }
++ for (auto it = my_jsFileWithPath.cbegin(), end = my_jsFileWithPath.cend(); it != end;
++ ++it) {
++ if (it.value() && it.value()->current && it.value()->current->isValid())
++ m_lastValidBase->m_jsFileWithPath.insert(it.key(), it.value());
++ }
++ m_lastValidBase->m_loadInfos.insert(my_loadInfos);
++ }
++
++ auto newBaseForPopulation =
++ m_lastValidBase ? m_lastValidBase->weak_from_this() : m_base->weak_from_this();
++ // adapt the factory to the use the base or valid environment for unpopulated files, instead of
++ // the current environment which will very probably be destroyed anytime soon
++ for (const auto &qmlFile : my_qmlFileWithPath) {
++ if (!qmlFile || !qmlFile->current)
++ continue;
++ QQmlJSScope::ConstPtr handle = qmlFile->current->handleForPopulation();
++ if (!handle)
++ continue;
++ auto oldFactory = handle.factory();
++ if (!oldFactory)
++ continue;
++
++ resetFactory(handle, oldFactory->importer(),
++ TypeReader{ newBaseForPopulation, m_loadPaths });
++ }
++ return true;
++ }
++
++ void DomEnvironment::loadPendingDependencies()
++ {
++ DomItem self(shared_from_this());
++ while (true) {
++ Path elToDo;
++ std::shared_ptr<LoadInfo> loadInfo;
++ {
++ QMutexLocker l(mutex());
++ if (m_loadsWithWork.isEmpty())
++ break;
++ elToDo = m_loadsWithWork.dequeue();
++ m_inProgress.append(elToDo);
++ loadInfo = m_loadInfos.value(elToDo);
++ }
++ if (loadInfo) {
++ auto cleanup = qScopeGuard([this, &elToDo, &self] {
++ QList<Callback> endCallbacks;
++ {
++ QMutexLocker l(mutex());
++ m_inProgress.removeOne(elToDo);
++ if (m_inProgress.isEmpty() && m_loadsWithWork.isEmpty()) {
++ endCallbacks = m_allLoadedCallback;
++ m_allLoadedCallback.clear();
++ }
++ }
++ for (const Callback &cb : std::as_const(endCallbacks))
++ cb(self.canonicalPath(), self, self);
++ });
++ DomItem loadInfoObj = self.copy(loadInfo);
++ loadInfo->advanceLoad(loadInfoObj);
++ } else {
++ self.addError(myErrors().error(u"DomEnvironment::loadPendingDependencies could not "
++ u"find loadInfo listed in m_loadsWithWork"_sv));
++ {
++ QMutexLocker l(mutex());
++ m_inProgress.removeOne(elToDo);
++ }
++ Q_ASSERT(false
++ && "DomEnvironment::loadPendingDependencies could not find loadInfo listed in "
++ "m_loadsWithWork");
++ }
++ }
++ }
++
++ bool DomEnvironment::finishLoadingDependencies(int waitMSec)
++ {
++ bool hasPendingLoads = true;
++ QDateTime endTime = QDateTime::currentDateTimeUtc().addMSecs(waitMSec);
++ for (int i = 0; i < waitMSec / 10 + 2; ++i) {
++ loadPendingDependencies();
++ auto lInfos = loadInfos();
++ auto it = lInfos.cbegin();
++ auto end = lInfos.cend();
++ hasPendingLoads = false;
++ while (it != end) {
++ if (*it && (*it)->status() != LoadInfo::Status::Done)
++ hasPendingLoads = true;
++ }
++ if (!hasPendingLoads)
++ break;
++ auto missing = QDateTime::currentDateTimeUtc().msecsTo(endTime);
++ if (missing < 0)
++ break;
++ if (missing > 100)
++ missing = 100;
++ #if QT_FEATURE_thread
++ QThread::msleep(missing);
++ #endif
++ }
++ return !hasPendingLoads;
++ }
++
++ void DomEnvironment::addWorkForLoadInfo(const Path &elementCanonicalPath)
++ {
++ QMutexLocker l(mutex());
++ m_loadsWithWork.enqueue(elementCanonicalPath);
++ }
++
++ DomEnvironment::Options DomEnvironment::options() const
++ {
++ return m_options;
++ }
++
++ std::shared_ptr<DomEnvironment> DomEnvironment::base() const
++ {
++ return m_base;
++ }
++
++ void DomEnvironment::setLoadPaths(const QStringList &v)
++ {
++ QMutexLocker l(mutex());
++ m_loadPaths = v;
++ }
++
++ void DomEnvironment::setResourceFiles(const QStringList &v)
++ {
++ QMutexLocker l(mutex());
++ m_resourcePaths = v;
++ }
++
++ QStringList DomEnvironment::loadPaths() const
++ {
++ QMutexLocker l(mutex());
++ return m_loadPaths;
++ }
++
++ QList<Import> DomEnvironment::defaultImplicitImports()
++ {
++ return QList<Import>({ Import::fromUriString(u"QML"_s, Version(1, 0)),
++ Import(QmlUri::fromUriString(u"QtQml"_s), Version(6, 0)) });
++ }
++
++ QList<Import> DomEnvironment::implicitImports() const
++ {
++ return m_implicitImports;
++ }
++
++ void DomEnvironment::addAllLoadedCallback(const DomItem &self, DomTop::Callback c)
++ {
++ if (c) {
++ bool immediate = false;
++ {
++ QMutexLocker l(mutex());
++ if (m_loadsWithWork.isEmpty() && m_inProgress.isEmpty())
++ immediate = true;
++ else
++ m_allLoadedCallback.append(c);
++ }
++ if (immediate)
++ c(Path(), self, self);
++ }
++ }
++
++ void DomEnvironment::clearReferenceCache()
++ {
++ m_referenceCache.clear();
++ }
++
++ void DomEnvironment::populateFromQmlFile(MutableDomItem &&qmlFile)
++ {
++ if (std::shared_ptr<QmlFile> qmlFilePtr = qmlFile.ownerAs<QmlFile>()) {
++ auto logger = std::make_shared<QQmlJSLogger>();
++ logger->setFilePath(qmlFile.canonicalFilePath());
++ logger->setCode(qmlFilePtr->code());
++ logger->setSilent(true);
++
++ auto setupFile = [&qmlFilePtr, &qmlFile, this](auto &&visitor) {
++ Q_UNUSED(this); // note: integrity requires "this" to be in the capture list, while
++ // other compilers complain about "this" being unused in the lambda
++ AST::Node::accept(qmlFilePtr->ast(), visitor);
++
++ if (m_domCreationOption == DomCreationOption::Minimal)
++ return;
++
++ CommentCollector collector(qmlFile);
++ collector.collectComments();
++ };
++
++ if (m_domCreationOption == DomCreationOption::Extended) {
++ SemanticAnalysis analysis = prepareSemanticAnalysisForFileLoading();
++ auto v = std::make_unique<QQmlDomAstCreatorWithQQmlJSScope>(qmlFile, logger.get(),
++ analysis.m_importer.get());
++ v->enableLoadFileLazily(true);
++ v->enableScriptExpressions(true);
++
++ setupFile(v.get());
++
++ auto typeResolver =
++ std::make_shared<QQmlJSTypeResolver>(analysis.m_importer.get());
++ typeResolver->init(&v->scopeCreator(), nullptr);
++ qmlFilePtr->setTypeResolverWithDependencies(
++ typeResolver, { analysis.m_importer, analysis.m_mapper, std::move(logger) });
++ } else {
++ auto v = std::make_unique<QQmlDomAstCreator>(qmlFile);
++ // we need file locations of script expressions in qmlformat for the "// qmlformat off"
++ // functionality
++ v->enableScriptExpressions(m_domCreationOption == DomCreationOption::Default);
++ setupFile(v.get());
++ }
++ } else {
++ qCWarning(domLog) << "populateQmlFile called on non qmlFile";
++ return;
++ }
++ }
++
++ QString ExternalItemInfoBase::canonicalFilePath(const DomItem &self) const
++ {
++ shared_ptr<ExternalOwningItem> current = currentItem();
++ DomItem currentObj = currentItem(self);
++ return current->canonicalFilePath(currentObj);
++ }
++
++ bool ExternalItemInfoBase::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
++ {
++ if (!self.invokeVisitorOnLazyField(visitor, Fields::currentRevision,
++ [this, &self]() { return currentRevision(self); }))
++ return false;
++ if (!self.invokeVisitorOnLazyField(visitor, Fields::lastRevision,
++ [this, &self]() { return lastRevision(self); }))
++ return false;
++ if (!self.invokeVisitorOnLazyField(visitor, Fields::lastValidRevision,
++ [this, &self]() { return lastValidRevision(self); }))
++ return false;
++ if (!visitor(PathEls::Field(Fields::currentItem),
++ [&self, this]() { return currentItem(self); }))
++ return false;
++ if (!self.invokeVisitorOnLazyField(visitor, Fields::currentExposedAt,
++ [this]() { return currentExposedAt(); }))
++ return false;
++ return true;
++ }
++
++ int ExternalItemInfoBase::currentRevision(const DomItem &) const
++ {
++ return currentItem()->revision();
++ }
++
++ int ExternalItemInfoBase::lastRevision(const DomItem &self) const
++ {
++ Path p = currentItem()->canonicalPath();
++ DomItem lastValue = self.universe()[p.mid(1, p.length() - 1)].field(u"revision");
++ return static_cast<int>(lastValue.value().toInteger(0));
++ }
++
++ int ExternalItemInfoBase::lastValidRevision(const DomItem &self) const
++ {
++ Path p = currentItem()->canonicalPath();
++ DomItem lastValidValue = self.universe()[p.mid(1, p.length() - 2)].field(u"validItem").field(u"revision");
++ return static_cast<int>(lastValidValue.value().toInteger(0));
++ }
++
++ QString ExternalItemPairBase::canonicalFilePath(const DomItem &) const
++ {
++ shared_ptr<ExternalOwningItem> current = currentItem();
++ return current->canonicalFilePath();
++ }
++
++ Path ExternalItemPairBase::canonicalPath(const DomItem &) const
++ {
++ shared_ptr<ExternalOwningItem> current = currentItem();
++ return current->canonicalPath().dropTail();
++ }
++
++ bool ExternalItemPairBase::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
++ {
++ if (!self.invokeVisitorOnLazyField(visitor, Fields::currentIsValid,
++ [this]() { return currentIsValid(); }))
++ return false;
++ if (!visitor(PathEls::Field(Fields::validItem), [this, &self]() { return validItem(self); }))
++ return false;
++ if (!visitor(PathEls::Field(Fields::currentItem),
++ [this, &self]() { return currentItem(self); }))
++ return false;
++ if (!self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::validExposedAt), validExposedAt))
++ return false;
++ if (!self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::currentExposedAt),
++ currentExposedAt)) {
++ return false;
++ }
++ return true;
++ }
++
++ bool ExternalItemPairBase::currentIsValid() const
++ {
++ return currentItem() == validItem();
++ }
++
++ RefCacheEntry RefCacheEntry::forPath(const DomItem &el, const Path &canonicalPath)
++ {
++ DomItem env = el.environment();
++ std::shared_ptr<DomEnvironment> envPtr = env.ownerAs<DomEnvironment>();
++ RefCacheEntry cached;
++ if (envPtr) {
++ QMutexLocker l(envPtr->mutex());
++ cached = envPtr->m_referenceCache.value(canonicalPath, {});
++ } else {
++ qCWarning(domLog) << "No Env for reference" << canonicalPath << "from"
++ << el.internalKindStr() << el.canonicalPath();
++ Q_ASSERT(false);
++ }
++ return cached;
++ }
++
++ bool RefCacheEntry::addForPath(const DomItem &el, const Path &canonicalPath, const RefCacheEntry &entry,
++ AddOption addOption)
++ {
++ DomItem env = el.environment();
++ std::shared_ptr<DomEnvironment> envPtr = env.ownerAs<DomEnvironment>();
++ bool didSet = false;
++ if (envPtr) {
++ QMutexLocker l(envPtr->mutex());
++ RefCacheEntry &cached = envPtr->m_referenceCache[canonicalPath];
++ switch (cached.cached) {
++ case RefCacheEntry::Cached::None:
++ cached = entry;
++ didSet = true;
++ break;
++ case RefCacheEntry::Cached::First:
++ if (addOption == AddOption::Overwrite || entry.cached == RefCacheEntry::Cached::All) {
++ cached = entry;
++ didSet = true;
++ }
++ break;
++ case RefCacheEntry::Cached::All:
++ if (addOption == AddOption::Overwrite || entry.cached == RefCacheEntry::Cached::All) {
++ cached = entry;
++ didSet = true;
++ }
++ }
++ if (cached.cached == RefCacheEntry::Cached::First && cached.canonicalPaths.isEmpty())
++ cached.cached = RefCacheEntry::Cached::All;
++ } else {
++ Q_ASSERT(false);
++ }
++ return didSet;
++ }
++
++ } // end namespace Dom
++ } // end namespace QQmlJS
++
++ QT_END_NAMESPACE
++
++ #include "moc_qqmldomtop_p.cpp"