Revision control
Copy as Markdown
// 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
#ifndef QQMLDOMEXTERNALITEMS_P_H
#define QQMLDOMEXTERNALITEMS_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include "qqmldomitem_p.h"
#include "qqmldomelements_p.h"
#include "qqmldomcomments_p.h"
#include <QtQml/private/qqmljsast_p.h>
#include <QtQml/private/qqmljsengine_p.h>
#include <QtQml/private/qqmldirparser_p.h>
#include <QtQmlCompiler/private/qqmljstyperesolver_p.h>
#include <QtCore/QMetaType>
#include <QtCore/qregularexpression.h>
#include <limits>
#include <memory>
Q_DECLARE_METATYPE(QQmlDirParser::Plugin)
QT_BEGIN_NAMESPACE
namespace QQmlJS {
namespace Dom {
/*!
\internal
\class QQmlJS::Dom::ExternalOwningItem
\brief A OwningItem that refers to an external resource (file,...)
Every owning item has a file or directory it refers to.
*/
class QMLDOM_EXPORT ExternalOwningItem: public OwningItem {
public:
ExternalOwningItem(
const QString &filePath, const QDateTime &lastDataUpdateAt, const Path &pathFromTop,
int derivedFrom = 0, const QString &code = QString());
ExternalOwningItem(const ExternalOwningItem &o) = default;
QString canonicalFilePath(const DomItem &) const override;
QString canonicalFilePath() const;
Path canonicalPath(const DomItem &) const override;
Path canonicalPath() const;
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const override
{
bool cont = OwningItem::iterateDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::canonicalFilePath, [this]() {
return canonicalFilePath();
});
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::isValid, [this]() {
return isValid();
});
if (!code().isNull())
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::code, [this]() {
return code();
});
return cont;
}
bool iterateSubOwners(const DomItem &self, function_ref<bool(const DomItem &owner)> visitor) override
{
bool cont = OwningItem::iterateSubOwners(self, visitor);
cont = cont && self.field(Fields::components).visitKeys([visitor](const QString &, const DomItem &comps) {
return comps.visitIndexes([visitor](const DomItem &comp) {
return comp.field(Fields::objects).visitIndexes([visitor](const DomItem &qmlObj) {
if (const QmlObject *qmlObjPtr = qmlObj.as<QmlObject>())
return qmlObjPtr->iterateSubOwners(qmlObj, visitor);
Q_ASSERT(false);
return true;
});
});
});
return cont;
}
bool isValid() const {
QMutexLocker l(mutex());
return m_isValid;
}
void setIsValid(bool val) {
QMutexLocker l(mutex());
m_isValid = val;
}
// null code means invalid
const QString &code() const { return m_code; }
protected:
QString m_canonicalFilePath;
QString m_code;
Path m_path;
bool m_isValid = false;
};
class QMLDOM_EXPORT JsFile final : public ExternalOwningItem
{
protected:
std::shared_ptr<OwningItem> doCopy(const DomItem &) const override
{
auto copy = std::make_shared<JsFile>(*this);
return copy;
}
public:
constexpr static DomType kindValue = DomType::JsFile;
DomType kind() const override { return kindValue; }
JsFile(const QString &filePath = QString(),
const QDateTime &lastDataUpdateAt = QDateTime::fromMSecsSinceEpoch(0, QTimeZone::UTC),
const Path &pathFromTop = Path(), int derivedFrom = 0)
: ExternalOwningItem(filePath, lastDataUpdateAt, pathFromTop, derivedFrom)
{
}
JsFile(const QString &filePath = QString(), const QString &code = QString(),
const QDateTime &lastDataUpdateAt = QDateTime::fromMSecsSinceEpoch(0, QTimeZone::UTC),
int derivedFrom = 0);
JsFile(const JsFile &o) = default;
std::shared_ptr<JsFile> makeCopy(const DomItem &self) const
{
return std::static_pointer_cast<JsFile>(doCopy(self));
}
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const
override; // iterates the *direct* subpaths, returns false if a quick end was requested
std::shared_ptr<QQmlJS::Engine> engine() const { return m_engine; }
JsResource rootComponent() const { return m_rootComponent; }
void setFileLocationsTree(const FileLocations::Tree &v) { m_fileLocationsTree = std::move(v); }
static ErrorGroups myParsingErrors();
void writeOut(const DomItem &self, OutWriter &lw) const override;
void setExpression(const std::shared_ptr<ScriptExpression> &script) { m_script = script; }
void initPragmaLibrary() { m_pragmaLibrary = LegacyPragmaLibrary{}; };
void addFileImport(const QString &jsfile, const QString &module);
void addModuleImport(const QString &uri, const QString &version, const QString &module);
private:
void writeOutDirectives(const DomItem &, OutWriter &lw) const;
/*
Entities with Legacy prefix are here to support formatting of the discouraged
.import, .pragma directives in .js files.
Taking into account that usage of these directives is discouraged and
the fact that current usecase is limited to the formatting of .js, it's arguably should not
be exposed and kept private.
LegacyPragma corresponds to the only one existing .pragma library
LegacyImport is capable of representing the following import statements:
.import T_STRING_LITERAL as T_IDENTIFIER
.import T_IDENTIFIER (. T_IDENTIFIER)* (T_VERSION_NUMBER (. T_VERSION_NUMBER)?)? as T_IDENTIFIER
LegacyDirectivesCollector is a workaround for collecting those directives.
At the moment of writing .import, .pragma in .js files do not have corresponding
representative AST::Node-s. Collecting of those is happening during the lexing
*/
struct LegacyPragmaLibrary
{
void writeOut(const DomItem &, OutWriter &lw) const;
};
struct LegacyImport
{
QString fileName; // file import
QString uri; // module import
QString version; // used for module import
QString asIdentifier; // .import ... as T_Identifier
void writeOut(const DomItem &, OutWriter &lw) const;
};
class LegacyDirectivesCollector : public QQmlJS::Directives
{
public:
LegacyDirectivesCollector(JsFile &file) : m_file(file){};
void pragmaLibrary() override { m_file.initPragmaLibrary(); };
void importFile(const QString &jsfile, const QString &module, int, int) override
{
m_file.addFileImport(jsfile, module);
};
void importModule(const QString &uri, const QString &version, const QString &module, int,
int) override
{
m_file.addModuleImport(uri, version, module);
};
private:
JsFile &m_file;
};
private:
std::shared_ptr<QQmlJS::Engine> m_engine;
std::optional<LegacyPragmaLibrary> m_pragmaLibrary = std::nullopt;
QList<LegacyImport> m_imports;
std::shared_ptr<ScriptExpression> m_script;
JsResource m_rootComponent;
FileLocations::Tree m_fileLocationsTree;
};
class QMLDOM_EXPORT QmlFile final : public ExternalOwningItem
{
protected:
std::shared_ptr<OwningItem> doCopy(const DomItem &self) const override;
public:
constexpr static DomType kindValue = DomType::QmlFile;
DomType kind() const override { return kindValue; }
enum RecoveryOption { DisableParserRecovery, EnableParserRecovery };
QmlFile(const QString &filePath = QString(), const QString &code = QString(),
const QDateTime &lastDataUpdate = QDateTime::fromMSecsSinceEpoch(0, QTimeZone::UTC),
int derivedFrom = 0, RecoveryOption option = DisableParserRecovery);
static ErrorGroups myParsingErrors();
bool iterateDirectSubpaths(const DomItem &self, DirectVisitor) const
override; // iterates the *direct* subpaths, returns false if a quick end was requested
DomItem field(const DomItem &self, QStringView name) const override;
std::shared_ptr<QmlFile> makeCopy(const DomItem &self) const
{
return std::static_pointer_cast<QmlFile>(doCopy(self));
}
void addError(const DomItem &self, ErrorMessage &&msg) override;
const QMultiMap<QString, QmlComponent> &components() const &
{
return lazyMembers().m_components;
}
void setComponents(const QMultiMap<QString, QmlComponent> &components)
{
lazyMembers().m_components = components;
}
Path addComponent(const QmlComponent &component, AddOption option = AddOption::Overwrite,
QmlComponent **cPtr = nullptr)
{
QStringList nameEls = component.name().split(QChar::fromLatin1('.'));
QString key = nameEls.mid(1).join(QChar::fromLatin1('.'));
return insertUpdatableElementInMultiMap(Path::fromField(Fields::components), lazyMembers().m_components,
key, component, option, cPtr);
}
void writeOut(const DomItem &self, OutWriter &lw) const override;
AST::UiProgram *ast() const
{
return m_ast; // avoid making it public? would make moving away from it easier
}
const QList<Import> &imports() const &
{
return lazyMembers().m_imports;
}
void setImports(const QList<Import> &imports) { lazyMembers().m_imports = imports; }
Path addImport(const Import &i)
{
auto &members = lazyMembers();
index_type idx = index_type(members.m_imports.size());
members.m_imports.append(i);
return Path::fromField(Fields::imports).withIndex(idx);
}
std::shared_ptr<QQmlJS::Engine> engine() const { return m_engine; }
RegionComments &comments() { return lazyMembers().m_comments; }
std::shared_ptr<AstComments> astComments() const { return lazyMembers().m_astComments; }
void setAstComments(const std::shared_ptr<AstComments> &comm) { lazyMembers().m_astComments = comm; }
FileLocations::Tree fileLocationsTree() const { return lazyMembers().m_fileLocationsTree; }
void setFileLocationsTree(const FileLocations::Tree &v) { lazyMembers().m_fileLocationsTree = v; }
const QList<Pragma> &pragmas() const & { return lazyMembers().m_pragmas; }
void setPragmas(QList<Pragma> pragmas) { lazyMembers().m_pragmas = pragmas; }
Path addPragma(const Pragma &pragma)
{
auto &members = lazyMembers();
int idx = members.m_pragmas.size();
members.m_pragmas.append(pragma);
return Path::fromField(Fields::pragmas).withIndex(idx);
}
std::shared_ptr<QQmlJSTypeResolver> typeResolver() const
{
return lazyMembers().m_typeResolver;
}
void setTypeResolverWithDependencies(const std::shared_ptr<QQmlJSTypeResolver> &typeResolver,
const QQmlJSTypeResolverDependencies &dependencies)
{
auto &members = lazyMembers();
members.m_typeResolver = typeResolver;
members.m_typeResolverDependencies = dependencies;
}
DomCreationOption creationOption() const { return lazyMembers().m_creationOption; }
QQmlJSScope::ConstPtr handleForPopulation() const
{
return m_handleForPopulation;
}
void setHandleForPopulation(const QQmlJSScope::ConstPtr &scope)
{
m_handleForPopulation = scope;
}
private:
// The lazy parts of QmlFile are inside of QmlFileLazy.
struct QmlFileLazy
{
QmlFileLazy(FileLocations::Tree fileLocationsTree, AstComments *astComments)
: m_fileLocationsTree(fileLocationsTree), m_astComments(astComments)
{
}
RegionComments m_comments;
QMultiMap<QString, QmlComponent> m_components;
QList<Pragma> m_pragmas;
QList<Import> m_imports;
FileLocations::Tree m_fileLocationsTree;
std::shared_ptr<AstComments> m_astComments;
DomCreationOption m_creationOption;
std::shared_ptr<QQmlJSTypeResolver> m_typeResolver;
QQmlJSTypeResolverDependencies m_typeResolverDependencies;
};
friend class QQmlDomAstCreatorBase;
AST::UiProgram *m_ast; // avoid? would make moving away from it easier
std::shared_ptr<Engine> m_engine;
QQmlJSScope::ConstPtr m_handleForPopulation;
mutable std::optional<QmlFileLazy> m_lazyMembers;
void ensurePopulated() const
{
if (m_lazyMembers)
return;
m_lazyMembers.emplace(FileLocations::createTree(canonicalPath()), new AstComments(m_engine));
// populate via the QQmlJSScope by accessing the (lazy) pointer
if (m_handleForPopulation.factory()) {
// silence no-discard attribute:
Q_UNUSED(m_handleForPopulation.data());
}
}
const QmlFileLazy &lazyMembers() const
{
ensurePopulated();
return *m_lazyMembers;
}
QmlFileLazy &lazyMembers()
{
ensurePopulated();
return *m_lazyMembers;
}
};
} // end namespace Dom
} // end namespace QQmlJS
QT_END_NAMESPACE
#endif // QQMLDOMEXTERNALITEMS_P_H