Revision control
Copy as Markdown
// Copyright (C) 2021 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
// Suppress GCC 11 warning about maybe-uninitialized copy of
// another Data. We're not sure if the compiler is actually right,
// but in this type of warning, it often isn't.
//#if defined(Q_CC_GNU) && Q_CC_GNU >= 1100
//QT_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
#include "qqmldomconstants_p.h"
#include "qqmldompath_p.h"
#if defined(__GNUC__) && __GNUC__ >= 11
# pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#include "qqmldomelements_p.h"
#include "qqmldomcomments_p.h"
#include "qqmldomastdumper_p.h"
#include "qqmldommock_p.h"
#include "qqmldomreformatter_p.h"
#include "qqmldomoutwriter_p.h"
#include "qqmldomlinewriter_p.h"
#include "qqmldomtop_p.h"
#include "qqmldomexternalitems_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 <QtCore/QScopeGuard>
#include <QtCore/QRegularExpression>
#include <QtCore/QDir>
#include <QtCore/QBasicMutex>
#include <QtCore/QUrl>
#include <optional>
#include <limits>
QT_BEGIN_NAMESPACE
using namespace Qt::StringLiterals;
namespace QQmlJS {
namespace Dom {
namespace Paths {
Path moduleIndexPath(const QString &uri, int majorVersion, const ErrorHandler &errorHandler)
{
QString version = QString::number(majorVersion);
if (majorVersion == Version::Latest)
version = QLatin1String("Latest");
else if (majorVersion == Version::Undefined)
version = QString();
QRegularExpression moduleRe(QLatin1String(R"(\A\w+(?:\.\w+)*\Z)"));
auto m = moduleRe.match(uri);
if (!m.isValid())
Path::myErrors()
.error(Path::tr("Invalid module name in import %1").arg(uri))
.handle(errorHandler);
return Path::fromRoot(PathRoot::Env).withField(Fields::moduleIndexWithUri).withKey(uri).withKey(version);
}
Path moduleScopePath(const QString &uri, Version version, const ErrorHandler &)
{
return Path::fromRoot(PathRoot::Env)
.withField(Fields::moduleIndexWithUri)
.withKey(uri)
.withKey(version.majorSymbolicString())
.withField(Fields::moduleScope)
.withKey(version.minorString());
}
Path moduleScopePath(const QString &uri, const QString &version, const ErrorHandler &errorHandler)
{
Version v = Version::fromString(version);
if (!version.isEmpty() && !(v.isValid() || v.isLatest()))
Path::myErrors().error(Path::tr("Invalid Version %1").arg(version)).handle(errorHandler);
return moduleScopePath(uri, v, errorHandler);
}
} // end namespace Paths
static ErrorGroups domParsingErrors()
{
static ErrorGroups res = { { DomItem::domErrorGroup, NewErrorGroup("Parsing") } };
return res;
}
bool CommentableDomElement::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, m_comments);
return cont;
}
void Component::updatePathFromOwner(const Path &newPath)
{
DomElement::updatePathFromOwner(newPath);
updatePathFromOwnerMultiMap(m_enumerations, newPath.withField(Fields::enumerations));
updatePathFromOwnerQList(m_objects, newPath.withField(Fields::objects));
}
Component::Component(const QString &name) : CommentableDomElement(Path()), m_name(name) { }
Component::Component(const Path &pathFromOwner) : CommentableDomElement(pathFromOwner) { }
bool Component::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = CommentableDomElement::iterateDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name());
cont = cont && self.invokeVisitorOnField(visitor, Fields::enumerations, m_enumerations);
cont = cont && self.invokeVisitorOnField(visitor, Fields::objects, m_objects);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isSingleton),
isSingleton());
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isCreatable),
isCreatable());
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isComposite),
isComposite());
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::attachedTypeName),
attachedTypeName());
cont = cont && self.invokeVisitorOnReference(visitor, Fields::attachedType, attachedTypePath(self));
return cont;
}
DomItem Component::field(const DomItem &self, QStringView name) const
{
if (name == Fields::name)
return self.wrap(PathEls::Field(Fields::name), m_name);
if (name == Fields::objects)
return self.wrap(PathEls::Field(Fields::objects), m_objects);
return DomBase::field(self, name);
}
Path Component::addObject(const QmlObject &object, QmlObject **oPtr)
{
return appendUpdatableElementInQList(pathFromOwner().withField(Fields::objects), m_objects, object,
oPtr);
}
bool QmlComponent::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = Component::iterateDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnField(visitor, Fields::ids, m_ids);
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::subComponents, [this, &self]() {
return this->subComponents(self);
});
if (m_nameIdentifiers) {
cont = cont && visitor(PathEls::Field(Fields::nameIdentifiers), [this, &self]() {
return self.subScriptElementWrapperItem(m_nameIdentifiers);
});
}
return cont;
}
void QmlComponent::updatePathFromOwner(const Path &newPath)
{
Component::updatePathFromOwner(newPath);
updatePathFromOwnerMultiMap(m_ids, newPath.withField(Fields::annotations));
}
void QmlComponent::writeOut(const DomItem &self, OutWriter &lw) const
{
if (name().contains(QLatin1Char('.'))) {
// inline component
const auto fLoc = FileLocations::treeOf(self);
lw.ensureNewline()
.writeRegion(fLoc, ComponentKeywordRegion)
.ensureSpace()
.writeRegion(fLoc, IdentifierRegion, name().split(QLatin1Char('.')).last())
.writeRegion(fLoc, ColonTokenRegion)
.ensureSpace();
}
self.field(Fields::objects).index(0).writeOut(lw);
}
QList<QString> QmlComponent::subComponentsNames(const DomItem &self) const
{
DomItem components = self.owner().field(Fields::components);
const QSet<QString> cNames = components.keys();
QString myNameDot = self.pathFromOwner()[1].headName();
if (!myNameDot.isEmpty())
myNameDot += QLatin1Char('.');
QList<QString> subNames;
for (const QString &cName : cNames)
if (cName.startsWith(myNameDot)
&& !QStringView(cName).mid(myNameDot.size()).contains(QLatin1Char('.'))
&& !cName.isEmpty())
subNames.append(cName);
std::sort(subNames.begin(), subNames.end());
return subNames;
}
QList<DomItem> QmlComponent::subComponents(const DomItem &self) const
{
DomItem components = self.owner().field(Fields::components);
QList<DomItem> res;
for (const QString &cName : subComponentsNames(self))
for (const DomItem &comp : components.key(cName).values())
res.append(comp);
return res;
}
Version Version::fromString(QStringView v)
{
if (v.isEmpty())
return Version(Latest, Latest);
QRegularExpression r(
QRegularExpression::anchoredPattern(QStringLiteral(uR"(([0-9]*)(?:\.([0-9]*))?)")));
auto m = r.matchView(v);
if (m.hasMatch()) {
bool ok;
int majorV = m.capturedView(1).toInt(&ok);
if (!ok)
majorV = Version::Undefined;
int minorV = m.capturedView(2).toInt(&ok);
if (!ok)
minorV = Version::Undefined;
return Version(majorV, minorV);
}
return {};
}
Version::Version(qint32 majorV, qint32 minorV) : majorVersion(majorV), minorVersion(minorV) { }
bool Version::isLatest() const
{
return majorVersion == Latest && minorVersion == Latest;
}
bool Version::isValid() const
{
return majorVersion >= 0 && minorVersion >= 0;
}
QString Version::stringValue() const
{
if (isLatest())
return QString();
if (minorVersion < 0) {
if (majorVersion < 0)
return QLatin1String(".");
else
return QString::number(majorVersion);
}
if (majorVersion < 0)
return QLatin1String(".") + QString::number(minorVersion);
return QString::number(majorVersion) + QChar::fromLatin1('.') + QString::number(minorVersion);
}
bool Version::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnField(visitor, Fields::majorVersion, majorVersion);
cont = cont && self.invokeVisitorOnField(visitor, Fields::minorVersion, minorVersion);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isLatest), isLatest());
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isValid), isValid());
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::stringValue, [this]() {
return this->stringValue();
});
return cont;
}
QRegularExpression Import::importRe()
{
static QRegularExpression res(QRegularExpression::anchoredPattern(QStringLiteral(
uR"((?<uri>\w+(?:\.\w+)*)(?:\W+(?<version>[0-9]+(?:\.[0-9]*)?))?(?:\W+as\W+(?<id>\w+))?$)")));
return res;
}
Import Import::fromUriString(
const QString &importStr, Version v, const QString &importId, const ErrorHandler &handler)
{
auto m = importRe().match(importStr);
if (m.hasMatch()) {
if (v.majorVersion == Version::Undefined && v.minorVersion == Version::Undefined)
v = Version::fromString(m.captured(2));
else if (!m.captured(u"version").isEmpty())
domParsingErrors()
.warning(tr("Version %1 in import string '%2' overridden by explicit "
"version %3")
.arg(m.captured(2), importStr, v.stringValue()))
.handle(handler);
QString resolvedImportId;
if (importId.isEmpty()) {
resolvedImportId = m.captured(u"importId");
} else {
if (!m.captured(u"importId").isEmpty()) {
domParsingErrors()
.warning(tr("namespace %1 in import string '%2' overridden by explicit "
"importId %3")
.arg(m.captured(u"importId"), importStr, importId))
.handle(handler);
}
resolvedImportId = importId;
}
return Import(QmlUri::fromUriString(m.captured(u"uri").trimmed()), v, resolvedImportId);
}
domParsingErrors()
.error(tr("Unexpected URI format in import '%1'").arg(importStr))
.handle(handler);
return Import();
}
Import Import::fromFileString(
const QString &importStr, const QString &importId, const ErrorHandler &)
{
return Import(QmlUri::fromDirectoryString(importStr), Version(), importId);
}
bool Import::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::uri), uri.toString());
cont = cont && self.invokeVisitorOnField(visitor, Fields::version, version);
if (!importId.isEmpty())
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::importId), importId);
if (implicit)
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::implicit), implicit);
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, comments);
return cont;
}
void Import::writeOut(const DomItem &self, OutWriter &ow) const
{
if (implicit)
return;
QString code;
const DomItem owner = self.owner();
if (std::shared_ptr<QmlFile> qmlFilePtr = self.ownerAs<QmlFile>())
code = qmlFilePtr->code();
// check for an empty line before the import, and preserve it
int preNewlines = 0;
const FileLocations::Tree fLoc = FileLocations::treeOf(self);
quint32 start = fLoc->info().fullRegion.offset;
if (size_t(code.size()) >= start) {
while (start != 0) {
QChar c = code.at(--start);
if (c == u'\n') {
if (++preNewlines == 2)
break;
} else if (!c.isSpace())
break;
}
}
if (preNewlines == 0)
++preNewlines;
ow.ensureNewline(preNewlines);
ow.writeRegion(fLoc, ImportTokenRegion).ensureSpace();
ow.writeRegion(fLoc, ImportUriRegion, uri.toString());
if (uri.isModule()) {
QString vString = version.stringValue();
if (!vString.isEmpty())
ow.ensureSpace().writeRegion(fLoc, VersionRegion, vString);
}
if (!importId.isEmpty()) {
ow.ensureSpace()
.writeRegion(fLoc, AsTokenRegion)
.ensureSpace()
.writeRegion(fLoc, IdNameRegion, importId);
}
}
Id::Id(const QString &idName, const Path &referredObject) : name(idName), referredObjectPath(referredObject) { }
bool Id::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name);
cont = cont && self.invokeVisitorOnReference(visitor, Fields::referredObject, referredObjectPath);
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, comments);
cont = cont && self.invokeVisitorOnField(visitor, Fields::annotations, annotations);
cont = cont && self.invokeVisitorOnField(visitor, Fields::value, value);
return cont;
}
void Id::updatePathFromOwner(const Path &newPath)
{
updatePathFromOwnerQList(annotations, newPath.withField(Fields::annotations));
}
Path Id::addAnnotation(const Path &selfPathFromOwner, const QmlObject &annotation, QmlObject **aPtr)
{
return appendUpdatableElementInQList(selfPathFromOwner.withField(Fields::annotations), annotations,
annotation, aPtr);
}
QmlObject::QmlObject(const Path &pathFromOwner) : CommentableDomElement(pathFromOwner) { }
bool QmlObject::iterateBaseDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = CommentableDomElement::iterateDirectSubpaths(self, visitor);
if (!idStr().isEmpty())
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::idStr), idStr());
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name());
if (!prototypePaths().isEmpty())
cont = cont && self.invokeVisitorOnReferences(visitor, Fields::prototypes, m_prototypePaths);
if (nextScopePath())
cont = cont && self.invokeVisitorOnReference(visitor, Fields::nextScope, nextScopePath());
cont = cont && self.invokeVisitorOnField(visitor, Fields::propertyDefs, m_propertyDefs);
cont = cont && self.invokeVisitorOnField(visitor, Fields::bindings, m_bindings);
cont = cont && self.invokeVisitorOnField(visitor, Fields::methods, m_methods);
cont = cont && self.invokeVisitorOnField(visitor, Fields::children, m_children);
cont = cont && self.invokeVisitorOnField(visitor, Fields::annotations, m_annotations);
cont = cont && visitor(PathEls::Field(Fields::propertyInfos), [this, &self]() {
return self.subMapItem(Map(
pathFromOwner().withField(Fields::propertyInfos),
[&self](const DomItem &map, const QString &k) {
auto pInfo = self.propertyInfoWithName(k);
return map.wrap(PathEls::Key(k), pInfo);
},
[&self](const DomItem &) { return self.propertyInfoNames(); },
QLatin1String("PropertyInfo")));
});
if (m_nameIdentifiers) {
cont = cont && visitor(PathEls::Field(Fields::nameIdentifiers), [this, &self]() {
return self.subScriptElementWrapperItem(m_nameIdentifiers);
});
}
return cont;
}
QList<QString> QmlObject::fields() const
{
static QList<QString> myFields(
{ Fields::comments.toString(), Fields::idStr.toString(),
Fields::name.toString(), Fields::prototypes.toString(),
Fields::nextScope.toString(), Fields::propertyDefs.toString(),
Fields::bindings.toString(), Fields::methods.toString(),
Fields::children.toString(), Fields::annotations.toString(),
Fields::propertyInfos.toString() });
return myFields;
}
bool QmlObject::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = iterateBaseDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::defaultPropertyName,
[this, &self]() { return defaultPropertyName(self); });
return cont;
}
DomItem QmlObject::field(const DomItem &self, QStringView name) const
{
if (name == Fields::name)
return self.subDataItem(PathEls::Field(Fields::name), this->name());
if (name == Fields::idStr) {
if (idStr().isEmpty())
return DomItem();
return self.subDataItem(PathEls::Field(Fields::idStr), idStr());
}
if (name == Fields::methods)
return self.wrap(PathEls::Field(Fields::methods), m_methods);
if (name == Fields::bindings)
return self.wrap(PathEls::Field(Fields::bindings), m_bindings);
if (name == Fields::comments)
return CommentableDomElement::field(self, name);
if (name == Fields::children)
return self.wrap(PathEls::Field(Fields::children), m_children);
if (name == Fields::nextScope) {
if (nextScopePath())
return self.subReferenceItem(PathEls::Field(Fields::nextScope), nextScopePath());
else
return DomItem();
}
if (name == Fields::prototypes) {
if (prototypePaths().isEmpty())
return DomItem();
return self.subReferencesItem(PathEls::Field(Fields::prototypes), m_prototypePaths);
}
if (name == Fields::annotations)
return self.wrap(PathEls::Field(Fields::annotations), m_annotations);
if (name == Fields::propertyDefs)
return self.wrap(PathEls::Field(Fields::propertyDefs), m_propertyDefs);
if (name == Fields::propertyInfos) {
// Need to explicitly copy self here since we might store this and call it later.
return self.subMapItem(Map(
pathFromOwner().withField(Fields::propertyInfos),
[copiedSelf = self](const DomItem &map, const QString &k) {
return map.wrap(PathEls::Key(k), copiedSelf.propertyInfoWithName(k));
},
[copiedSelf = self](const DomItem &) { return copiedSelf.propertyInfoNames(); },
QLatin1String("PropertyInfo")));
}
if (name == Fields::nameIdentifiers && m_nameIdentifiers) {
return self.subScriptElementWrapperItem(m_nameIdentifiers);
}
if (name == Fields::defaultPropertyName) {
return self.subDataItem(PathEls::Field(Fields::defaultPropertyName),
defaultPropertyName(self));
}
static QStringList knownLookups({ Fields::fileLocationsTree.toString() });
if (!knownLookups.contains(name)) {
qCWarning(domLog()) << "Asked non existing field " << name << " in QmlObject "
<< pathFromOwner();
}
return DomItem();
}
void QmlObject::updatePathFromOwner(const Path &newPath)
{
DomElement::updatePathFromOwner(newPath);
updatePathFromOwnerMultiMap(m_propertyDefs, newPath.withField(Fields::propertyDefs));
updatePathFromOwnerMultiMap(m_bindings, newPath.withField(Fields::bindings));
updatePathFromOwnerMultiMap(m_methods, newPath.withField(Fields::methods));
updatePathFromOwnerQList(m_children, newPath.withField(Fields::children));
updatePathFromOwnerQList(m_annotations, newPath.withField(Fields::annotations));
}
QString QmlObject::localDefaultPropertyName() const
{
if (!m_defaultPropertyName.isEmpty())
return m_defaultPropertyName;
for (const PropertyDefinition &pDef : m_propertyDefs)
if (pDef.isDefaultMember)
return pDef.name;
return QString();
}
QString QmlObject::defaultPropertyName(const DomItem &self) const
{
QString dProp = localDefaultPropertyName();
if (!dProp.isEmpty())
return dProp;
QString res = QStringLiteral(u"data");
self.visitPrototypeChain(
[&res](const DomItem &obj) {
if (const QmlObject *objPtr = obj.as<QmlObject>()) {
QString dProp = objPtr->localDefaultPropertyName();
if (!dProp.isEmpty()) {
res = dProp;
return false;
}
}
return true;
},
VisitPrototypesOption::SkipFirst);
return res;
}
bool QmlObject::iterateSubOwners(const DomItem &self, function_ref<bool(const DomItem &)> visitor) const
{
bool cont = self.field(Fields::bindings).visitKeys([visitor](const QString &, const DomItem &bs) {
return bs.visitIndexes([visitor](const DomItem &b) {
DomItem v = b.field(Fields::value);
if (std::shared_ptr<ScriptExpression> vPtr = v.ownerAs<ScriptExpression>()) {
if (!visitor(v))
return false;
return v.iterateSubOwners(visitor); // currently not needed, avoid?
}
return true;
});
});
cont = cont && self.field(Fields::children).visitIndexes([visitor](const DomItem &qmlObj) {
if (const QmlObject *qmlObjPtr = qmlObj.as<QmlObject>()) {
return qmlObjPtr->iterateSubOwners(qmlObj, visitor);
}
Q_ASSERT(false);
return true;
});
return cont;
}
static QStringList dotExpressionToList(const std::shared_ptr<ScriptExpression> &expr)
{
QStringList res;
AST::Node *node = (expr ? expr->ast() : nullptr);
while (node) {
switch (node->kind) {
case AST::Node::Kind_IdentifierExpression: {
AST::IdentifierExpression *id = AST::cast<AST::IdentifierExpression *>(node);
res.prepend(id->name.toString());
return res;
}
case AST::Node::Kind_FieldMemberExpression: {
AST::FieldMemberExpression *id = AST::cast<AST::FieldMemberExpression *>(node);
res.prepend(id->name.toString());
node = id->base;
break;
}
default:
qCDebug(writeOutLog).noquote() << "Could not convert dot expression to list for:\n"
<< expr->astRelocatableDump();
return QStringList();
}
}
return res;
}
LocallyResolvedAlias QmlObject::resolveAlias(const DomItem &self,
std::shared_ptr<ScriptExpression> accessSequence) const
{
QStringList accessSequenceList = dotExpressionToList(accessSequence);
return resolveAlias(self, accessSequenceList);
}
LocallyResolvedAlias QmlObject::resolveAlias(const DomItem &self, const QStringList &accessSequence) const
{
LocallyResolvedAlias res;
QSet<QString> visitedAlias;
if (accessSequence.isEmpty()) {
return res;
} else if (accessSequence.size() > 3) {
res.status = LocallyResolvedAlias::Status::TooDeep;
return res;
}
QString idName = accessSequence.first();
DomItem idTarget = self.component()
.field(Fields::ids)
.key(idName)
.index(0)
.field(Fields::referredObject)
.get();
if (!idTarget)
return res;
res.baseObject = idTarget;
res.accessedPath = accessSequence.mid(1);
res.typeName = idTarget.name();
res.status = LocallyResolvedAlias::Status::ResolvedObject;
// check if it refers to locally defined props/objs
while (!res.accessedPath.isEmpty()) {
QString pNow = res.accessedPath.first();
DomItem defNow = res.baseObject.propertyDefs().key(pNow).index(0);
if (const PropertyDefinition *defNowPtr = defNow.as<PropertyDefinition>()) {
if (defNowPtr->isAlias()) {
res.typeName = QString();
++res.nAliases;
QString aliasPath = defNow.canonicalPath().toString();
if (visitedAlias.contains(aliasPath)) {
res.status = LocallyResolvedAlias::Status::Loop;
return res;
}
visitedAlias.insert(aliasPath);
DomItem valNow = res.baseObject.bindings().key(pNow).index(0);
if (std::shared_ptr<ScriptExpression> exp =
valNow.field(Fields::value).ownerAs<ScriptExpression>()) {
QStringList expList = dotExpressionToList(exp);
if (expList.isEmpty()) {
res.status = LocallyResolvedAlias::Status::Invalid;
return res;
} else if (expList.size() > 3) {
res.status = LocallyResolvedAlias::Status::TooDeep;
return res;
}
idName = expList.first();
idTarget = self.component()
.field(Fields::ids)
.key(idName)
.index(0)
.field(Fields::referredObject)
.get();
res.baseObject = idTarget;
res.accessedPath = expList.mid(1) + res.accessedPath.mid(1);
if (!idTarget) {
res.status = LocallyResolvedAlias::Status::Invalid;
return res;
}
res.status = LocallyResolvedAlias::Status::ResolvedObject;
res.typeName = idTarget.name();
} else {
res.status = LocallyResolvedAlias::Status::Invalid;
return res;
}
} else {
res.localPropertyDef = defNow;
res.typeName = defNowPtr->typeName;
res.accessedPath = res.accessedPath.mid(1);
DomItem valNow = res.baseObject.bindings().key(pNow).index(0).field(Fields::value);
if (valNow.internalKind() == DomType::QmlObject) {
res.baseObject = valNow;
res.typeName = valNow.name();
res.status = LocallyResolvedAlias::Status::ResolvedObject;
} else {
res.status = LocallyResolvedAlias::Status::ResolvedProperty;
return res;
}
}
} else {
return res;
}
}
return res;
}
MutableDomItem QmlObject::addPropertyDef(
MutableDomItem &self, const PropertyDefinition &propertyDef, AddOption option)
{
Path p = addPropertyDef(propertyDef, option);
if (p.last().headIndex(0) > 1)
self.owningItemPtr()->addErrorLocal(domParsingErrors().error(
tr("Repeated PropertyDefinition with name %1").arg(propertyDef.name)));
return self.owner().path(p);
}
MutableDomItem QmlObject::addBinding(MutableDomItem &self, const Binding &binding, AddOption option)
{
Path p = addBinding(binding, option);
if (p && p.last().headIndex(0) > 1)
self.owningItemPtr()->addErrorLocal(
domParsingErrors().error(tr("Repeated binding with name %1").arg(binding.name())));
return self.owner().path(p);
}
MutableDomItem QmlObject::addMethod(
MutableDomItem &self, const MethodInfo &functionDef, AddOption option)
{
Path p = addMethod(functionDef, option);
if (p.last().headIndex(0) > 1)
self.owningItemPtr()->addErrorLocal(
domParsingErrors().error(tr("Repeated Method with name %1").arg(functionDef.name)));
return self.owner().path(p);
}
void QmlObject::writeOutId(const DomItem &self, OutWriter &ow) const
{
if (!idStr().isEmpty()) { // *always* put id first
DomItem myId = self.component().field(Fields::ids).key(idStr()).index(0);
myId.writeOutPre(ow);
const auto fLoc = FileLocations::treeOf(myId);
ow.ensureNewline()
.writeRegion(fLoc, IdTokenRegion)
.writeRegion(fLoc, IdColonTokenRegion)
.ensureSpace()
.writeRegion(fLoc, IdNameRegion, idStr());
if (myId) {
myId.writeOutPost(ow);
ow.ensureNewline(1);
}
}
}
QList<std::pair<SourceLocation, DomItem>> QmlObject::orderOfAttributes(const DomItem &self,
const DomItem &component) const
{
auto startLoc = [&](const FileLocations::Tree &l) {
if (l)
return l->info().fullRegion;
return SourceLocation(posOfNewElements, 0, 0, 0);
};
QList<std::pair<SourceLocation, DomItem>> attribs;
const auto objLocPtr = FileLocations::treeOf(self);
FileLocations::Tree componentLoc;
if (component && objLocPtr)
componentLoc = objLocPtr->parent()->parent();
auto addMMap = [&attribs, &startLoc](const DomItem &base, const FileLocations::Tree &baseLoc) {
if (!base)
return;
const auto values = base.values();
for (const auto &els : values) {
FileLocations::Tree elsLoc = FileLocations::find(baseLoc, els.pathFromOwner().last());
const auto elsValues = els.values();
for (const auto &el : elsValues) {
FileLocations::Tree elLoc = FileLocations::find(elsLoc, el.pathFromOwner().last());
attribs.append(std::make_pair(startLoc(elLoc), el));
}
}
};
auto addMyMMap = [this, &objLocPtr, &self, &addMMap](QStringView fieldName) {
DomItem base = this->field(self, fieldName);
addMMap(base, FileLocations::find(objLocPtr, base.pathFromOwner().last()));
};
auto addSingleLevel = [&attribs, &startLoc](const DomItem &base,
const FileLocations::Tree &baseLoc) {
if (!base)
return;
const auto baseValues = base.values();
for (const auto &el : baseValues) {
FileLocations::Tree elLoc = FileLocations::find(baseLoc, el.pathFromOwner().last());
attribs.append(std::make_pair(startLoc(elLoc), el));
}
};
if (component) {
DomItem enums = component.field(Fields::enumerations);
addMMap(enums, FileLocations::find(componentLoc, enums.pathFromOwner().last()));
}
addMyMMap(Fields::propertyDefs);
addMyMMap(Fields::bindings);
addMyMMap(Fields::methods);
DomItem children = field(self, Fields::children);
addSingleLevel(children, FileLocations::find(objLocPtr, children.pathFromOwner().last()));
if (component) {
DomItem subCs = component.field(Fields::subComponents);
for (const DomItem &c : subCs.values()) {
const auto subLocPtr = FileLocations::treeOf(c);
Q_ASSERT(subLocPtr);
attribs.append(std::make_pair(startLoc(subLocPtr), c));
}
}
std::stable_sort(attribs.begin(), attribs.end(),
[](const std::pair<SourceLocation, DomItem> &el1,
const std::pair<SourceLocation, DomItem> &el2) {
if (el1.first.offset < el2.first.offset)
return true;
if (el1.first.offset > el2.first.offset)
return false;
int i = int(el1.second.internalKind()) - int(el2.second.internalKind());
return i < 0;
});
return attribs;
}
void QmlObject::writeOutAttributes(OutWriter &ow, const Attributes &attribs,
const QString &code) const
{
qsizetype iAttr = 0;
while (iAttr != attribs.size()) {
auto &el = attribs[iAttr++];
// check for an empty line before the current element, and preserve it
int preNewlines = 0;
quint32 start = el.first.offset;
if (start != posOfNewElements && size_t(code.size()) >= start) {
while (start != 0) {
QChar c = code.at(--start);
if (c == u'\n') {
if (++preNewlines == 2)
break;
} else if (!c.isSpace())
break;
}
}
if (preNewlines == 0)
++preNewlines;
ow.ensureNewline(preNewlines);
if (el.second.internalKind() == DomType::PropertyDefinition && iAttr != attribs.size()
&& el.first.offset != ~quint32(0)) {
DomItem b;
auto &bPair = attribs[iAttr];
if (bPair.second.internalKind() == DomType::Binding
&& bPair.first.begin() < el.first.end()
&& bPair.second.name() == el.second.name()) {
b = bPair.second;
++iAttr;
b.writeOutPre(ow);
}
el.second.writeOut(ow);
if (b) {
const auto fLoc = FileLocations::treeOf(b);
ow.writeRegion(fLoc, ColonTokenRegion);
ow.ensureSpace();
if (const Binding *bPtr = b.as<Binding>())
bPtr->writeOutValue(b, ow);
else {
qWarning() << "Internal error casting binding to Binding in"
<< b.canonicalPath();
ow.writeRegion(fLoc, LeftBraceRegion).writeRegion(fLoc, RightBraceRegion);
}
b.writeOutPost(ow);
}
} else {
el.second.writeOut(ow);
}
ow.ensureNewline();
}
}
static QStringList keepKeysOrder(const QList<std::pair<SourceLocation, DomItem>> &attribs,
const QStringList &keys)
{
QStringList originalOrderedKeys;
for (const auto &attrib : attribs) {
QString defName = attrib.second.name();
if (keys.contains(defName) && !originalOrderedKeys.contains(defName))
originalOrderedKeys.append(std::move(defName));
}
return originalOrderedKeys;
}
static QList<DomItem> keepDomItemsOrder(const QList<std::pair<SourceLocation, DomItem>> &attribs,
const QStringView &field, const DomItem &refItem)
{
DomItem item = refItem.field(field);
QList<DomItem> values = item.values();
QList<DomItem> originalValuesOrder;
for (const auto &attrib : attribs) {
DomItem itemValue = item.key(attrib.second.name());
if (values.contains(itemValue) && !originalValuesOrder.contains(itemValue))
originalValuesOrder.append(std::move(itemValue));
}
return originalValuesOrder;
}
void QmlObject::writeOutSortedEnumerations(const QList<DomItem> &descs, OutWriter &ow) const
{
for (const auto &enumDescs : descs) {
const auto values = enumDescs.values();
for (const auto &enumDesc : values) {
ow.ensureNewline(1);
enumDesc.writeOut(ow);
ow.ensureNewline(1);
}
}
}
void QmlObject::writeOutSortedPropertyDefinition(const DomItem &self, OutWriter &ow,
QSet<QString> &mergedDefBinding,
const QStringList &keys) const
{
DomItem propertyDefs = field(self, Fields::propertyDefs);
DomItem bindings = field(self, Fields::bindings);
for (const QString &defName : keys) {
const auto pDefs = propertyDefs.key(defName).values();
for (const auto &pDef : pDefs) {
const PropertyDefinition *pDefPtr = pDef.as<PropertyDefinition>();
Q_ASSERT(pDefPtr);
DomItem b;
bool uniqueDeclarationWithThisName = pDefs.size() == 1;
if (uniqueDeclarationWithThisName && !pDefPtr->isRequired)
bindings.key(pDef.name()).visitIndexes([&b, pDefPtr](const DomItem &el) {
const Binding *elPtr = el.as<Binding>();
if (elPtr && elPtr->bindingType() == BindingType::Normal) {
switch (elPtr->valueKind()) {
case BindingValueKind::ScriptExpression:
b = el;
break;
case BindingValueKind::Array:
if (!pDefPtr->isDefaultMember && pDefPtr->isParametricType())
b = el;
break;
case BindingValueKind::Object:
if (!pDefPtr->isDefaultMember && !pDefPtr->isParametricType())
b = el;
break;
case BindingValueKind::Empty:
break;
}
return false;
}
return true;
});
if (b) {
mergedDefBinding.insert(defName);
b.writeOutPre(ow);
}
pDef.writeOut(ow);
if (b) {
const auto fLoc = FileLocations::treeOf(b);
ow.writeRegion(fLoc, ColonTokenRegion);
ow.ensureSpace();
if (const Binding *bPtr = b.as<Binding>())
bPtr->writeOutValue(b, ow);
else {
qWarning() << "Internal error casting binding to Binding in"
<< b.canonicalPath();
ow.writeRegion(fLoc, LeftBraceRegion).writeRegion(fLoc, RightBraceRegion);
}
b.writeOutPost(ow);
}
}
}
}
static std::pair<QList<DomItem>, QList<DomItem>>
splitSignalsAndMethods(const QList<DomItem> &fields)
{
QList<DomItem> signalList, methodList;
for (const auto &ms : fields) {
const auto values = ms.values();
for (const auto &m : values) {
const MethodInfo *mPtr = m.as<MethodInfo>();
if (mPtr && mPtr->methodType == MethodInfo::MethodType::Signal)
signalList.append(m);
else
methodList.append(m);
}
}
return std::make_pair(signalList, methodList);
}
static std::tuple<QList<DomItem>, QList<DomItem>, QList<DomItem>>
splitBindings(const DomItem &bindings, const QSet<QString> &mergedDefBinding,
const QStringList &keys)
{
QList<DomItem> normalBindings, signalHandlers, delayedBindings;
for (const auto &bName : keys) {
bool skipFirstNormal = mergedDefBinding.contains(bName);
const auto values = bindings.key(bName).values();
for (const auto &b : values) {
const Binding *bPtr = b.as<Binding>();
if (skipFirstNormal) {
if (bPtr && bPtr->bindingType() == BindingType::Normal) {
skipFirstNormal = false;
continue;
}
}
if (bPtr->valueKind() == BindingValueKind::Array
|| bPtr->valueKind() == BindingValueKind::Object)
delayedBindings.append(b);
else if (b.field(Fields::isSignalHandler).value().toBool(false))
signalHandlers.append(b);
else
normalBindings.append(b);
}
}
return std::make_tuple(normalBindings, signalHandlers, delayedBindings);
}
void QmlObject::writeOutSortedAttributes(const DomItem &self, OutWriter &ow,
const DomItem &component, const Attributes &attribs) const
{
int spacerId = 0;
quint32 counter = ow.counter();
if (component)
writeOutSortedEnumerations(
ow.lineWriter.options().groupAttributesTogether
? keepDomItemsOrder(attribs, Fields::enumerations, component)
: component.field(Fields::enumerations).values(),
ow);
if (counter != ow.counter() || !idStr().isEmpty())
spacerId = ow.addNewlinesAutospacerCallback(2);
QSet<QString> mergedDefBinding;
QStringList propertyDefsKeys = field(self, Fields::propertyDefs).sortedKeys();
writeOutSortedPropertyDefinition(self, ow, mergedDefBinding,
ow.lineWriter.options().groupAttributesTogether
? keepKeysOrder(attribs, propertyDefsKeys)
: propertyDefsKeys);
ow.removeTextAddCallback(spacerId);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
const auto [signalList, methodList] =
splitSignalsAndMethods(ow.lineWriter.options().groupAttributesTogether
? keepDomItemsOrder(attribs, Fields::methods, self)
: field(self, Fields::methods).values());
for (const auto &sig : std::as_const(signalList)) {
ow.ensureNewline();
sig.writeOut(ow);
ow.ensureNewline();
}
ow.removeTextAddCallback(spacerId);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
bool first = true;
for (const auto &method : std::as_const(methodList)) {
if (!first && ow.lineWriter.options().functionsSpacing) {
ow.newline();
}
ow.ensureNewline();
first = false;
method.writeOut(ow);
ow.ensureNewline();
}
ow.removeTextAddCallback(spacerId);
DomItem bindings = field(self, Fields::bindings);
QStringList bindingsKeys = bindings.sortedKeys();
const auto [normalBindings, signalHandlers, delayedBindings] = splitBindings(
bindings, mergedDefBinding,
ow.lineWriter.options().groupAttributesTogether ? keepKeysOrder(attribs, bindingsKeys)
: bindingsKeys);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
for (const auto &b : std::as_const(normalBindings))
b.writeOut(ow);
ow.removeTextAddCallback(spacerId);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
for (const auto &b : std::as_const(delayedBindings))
b.writeOut(ow);
ow.removeTextAddCallback(spacerId);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
for (const auto &b : std::as_const(signalHandlers))
b.writeOut(ow);
ow.removeTextAddCallback(spacerId);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
first = true;
const auto values = field(self, Fields::children).values();
for (const auto &c : values) {
if (!first && ow.lineWriter.options().objectsSpacing) {
ow.newline().newline();
}
first = false;
ow.ensureNewline();
c.writeOut(ow);
}
ow.removeTextAddCallback(spacerId);
if (component) {
// we are a root object, possibly add components
DomItem subComps = component.field(Fields::subComponents);
if (counter != ow.counter())
spacerId = ow.addNewlinesAutospacerCallback(2);
const auto values = subComps.values();
for (const auto &subC : values) {
ow.ensureNewline();
subC.writeOut(ow);
}
ow.removeTextAddCallback(spacerId);
}
if (counter != ow.counter() || !ow.lineWriter.options().singleLineEmptyObjects)
ow.ensureNewline();
}
void QmlObject::writeOut(const DomItem &self, OutWriter &ow, const QString &onTarget) const
{
bool isRootObject = pathFromOwner().length() == 5
&& pathFromOwner()[0] == Path::fromField(Fields::components)
&& pathFromOwner()[3] == Path::fromField(Fields::objects);
const auto fLoc = FileLocations::treeOf(self);
ow.writeRegion(fLoc, IdentifierRegion, name());
if (!onTarget.isEmpty()) {
ow.ensureSpace()
.writeRegion(fLoc, OnTokenRegion)
.ensureSpace()
.writeRegion(fLoc, OnTargetRegion, onTarget);
}
ow.ensureSpace();
ow.writeRegion(fLoc, LeftBraceRegion);
DomItem component;
if (isRootObject)
component = self.containingObject();
const Attributes attributes = orderOfAttributes(self, component);
// *always* put id first
writeOutId(self, ow);
if (!idStr().isEmpty() && ow.lineWriter.options().attributesSequence
== LineWriterOptions::AttributesSequence::Normalize) {
ow.ensureNewline(attributes.empty() ? 1 : 2);
}
if (ow.lineWriter.options().attributesSequence
== LineWriterOptions::AttributesSequence::Preserve) {
QString code;
if (std::shared_ptr<QmlFile> qmlFilePtr = self.ownerAs<QmlFile>())
code = qmlFilePtr->code();
writeOutAttributes(ow, attributes, code);
} else {
writeOutSortedAttributes(self, ow, component, attributes);
}
ow.writeRegion(fLoc, RightBraceRegion);
}
Binding::Binding(const QString &name) : Binding(name, std::unique_ptr<BindingValue>()) { }
Binding::Binding(const QString &name, std::unique_ptr<BindingValue> &&value,
BindingType bindingType)
: m_bindingType(bindingType), m_name(name), m_value(std::move(value))
{
}
Binding::Binding(
const QString &name, const std::shared_ptr<ScriptExpression> &value,
BindingType bindingType)
: Binding(name, std::make_unique<BindingValue>(value), bindingType)
{
}
Binding::Binding(const QString &name, const QString &scriptCode, BindingType bindingType)
: Binding(name,
std::make_unique<BindingValue>(std::make_shared<ScriptExpression>(
scriptCode, ScriptExpression::ExpressionType::BindingExpression)),
bindingType)
{
}
Binding::Binding(const QString &name, const QmlObject &value, BindingType bindingType)
: Binding(name, std::make_unique<BindingValue>(value), bindingType)
{
}
Binding::Binding(const QString &name, const QList<QmlObject> &value, BindingType bindingType)
: Binding(name, std::make_unique<BindingValue>(value), bindingType)
{
}
Binding::Binding(const Binding &o)
: m_bindingType(o.m_bindingType),
m_name(o.m_name),
m_annotations(o.m_annotations),
m_comments(o.m_comments),
m_bindingIdentifiers(o.m_bindingIdentifiers)
{
if (o.m_value) {
m_value = std::make_unique<BindingValue>(*o.m_value);
}
}
Binding::~Binding() { }
Binding &Binding::operator=(const Binding &o)
{
m_name = o.m_name;
m_bindingType = o.m_bindingType;
m_annotations = o.m_annotations;
m_comments = o.m_comments;
m_bindingIdentifiers = o.m_bindingIdentifiers;
if (o.m_value) {
if (!m_value)
m_value = std::make_unique<BindingValue>(*o.m_value);
else
*m_value = *o.m_value;
} else {
m_value.reset();
}
return *this;
}
bool Binding::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), m_name);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isSignalHandler),
isSignalHandler());
if (!m_value)
cont = cont && visitor(PathEls::Field(Fields::value), []() { return DomItem(); });
else
cont = cont && visitor(PathEls::Field(Fields::value), [this, &self]() {
return m_value->value(self);
});
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::bindingType),
int(m_bindingType));
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, m_comments);
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::preCode, [this]() {
return this->preCode();
});
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::postCode, [this]() {
return this->postCode();
});
if (m_bindingIdentifiers) {
cont = cont && visitor(PathEls::Field(Fields::bindingIdentifiers), [this, &self]() {
return self.subScriptElementWrapperItem(m_bindingIdentifiers);
});
}
cont = cont && self.invokeVisitorOnField(visitor, Fields::annotations, m_annotations);
return cont;
}
DomItem Binding::valueItem(const DomItem &self) const
{
if (!m_value)
return DomItem();
return m_value->value(self);
}
BindingValueKind Binding::valueKind() const
{
if (!m_value)
return BindingValueKind::Empty;
return m_value->kind;
}
QmlObject const *Binding::objectValue() const
{
if (valueKind() == BindingValueKind::Object)
return &(m_value->object);
return nullptr;
}
QmlObject *Binding::objectValue()
{
if (valueKind() == BindingValueKind::Object)
return &(m_value->object);
return nullptr;
}
QList<QmlObject> const *Binding::arrayValue() const
{
if (valueKind() == BindingValueKind::Array)
return &(m_value->array);
return nullptr;
}
QList<QmlObject> *Binding::arrayValue()
{
if (valueKind() == BindingValueKind::Array)
return &(m_value->array);
return nullptr;
}
std::shared_ptr<ScriptExpression> Binding::scriptExpressionValue() const
{
if (valueKind() == BindingValueKind::ScriptExpression)
return m_value->scriptExpression;
return nullptr;
}
std::shared_ptr<ScriptExpression> Binding::scriptExpressionValue()
{
if (valueKind() == BindingValueKind::ScriptExpression)
return m_value->scriptExpression;
return nullptr;
}
void Binding::setValue(std::unique_ptr<BindingValue> &&value)
{
m_value = std::move(value);
}
Path Binding::addAnnotation(const Path &selfPathFromOwner, const QmlObject &annotation, QmlObject **aPtr)
{
return appendUpdatableElementInQList(selfPathFromOwner.withField(Fields::annotations),
m_annotations, annotation, aPtr);
}
void Binding::updatePathFromOwner(const Path &newPath)
{
Path base = newPath.withField(Fields::annotations);
if (m_value)
m_value->updatePathFromOwner(newPath.withField(Fields::value));
updatePathFromOwnerQList(m_annotations, newPath.withField(Fields::annotations));
}
void Binding::writeOut(const DomItem &self, OutWriter &lw) const
{
const auto fLoc = FileLocations::treeOf(self);
lw.ensureNewline();
if (m_bindingType == BindingType::Normal) {
lw.writeRegion(fLoc, IdentifierRegion, name());
lw.writeRegion(fLoc, ColonTokenRegion).ensureSpace();
writeOutValue(self, lw);
} else {
DomItem v = valueItem(self);
if (const QmlObject *vPtr = v.as<QmlObject>()) {
v.writeOutPre(lw);
vPtr->writeOut(v, lw, name());
v.writeOutPost(lw);
} else {
qCWarning(writeOutLog()) << "On Binding requires an QmlObject Value, not "
<< v.internalKindStr() << " at " << self.canonicalPath();
}
}
}
void Binding::writeOutValue(const DomItem &self, OutWriter &lw) const
{
DomItem v = valueItem(self);
const auto fLoc = FileLocations::treeOf(v);
switch (valueKind()) {
case BindingValueKind::Empty:
qCWarning(writeOutLog()) << "Writing of empty binding " << name();
lw.writeRegion(fLoc, LeftBraceRegion);
lw.writeRegion(fLoc, RightBraceRegion);
break;
case BindingValueKind::Array:
if (const List *vPtr = v.as<List>()) {
v.writeOutPre(lw);
vPtr->writeOut(v, lw, false);
v.writeOutPost(lw);
}
break;
case BindingValueKind::Object:
case BindingValueKind::ScriptExpression:
v.writeOut(lw);
break;
}
}
Export Export::fromString(
const Path &source, QStringView exp, const Path &typePath, const ErrorHandler &h)
{
Export res;
res.exportSourcePath = source;
res.typePath = typePath;
int slashIdx = exp.indexOf(QLatin1Char('/'));
int spaceIdx = exp.indexOf(QLatin1Char(' '));
if (spaceIdx == -1)
spaceIdx = exp.size();
else
res.version = Version::fromString(exp.mid(spaceIdx + 1));
if (!res.version.isValid())
domParsingErrors()
.error(tr("Expected string literal to contain 'Package/Name major.minor' "
"or 'Name major.minor' not '%1'.")
.arg(exp))
.handle(h);
if (slashIdx != -1)
res.uri = exp.left(slashIdx).toString();
res.typeName = exp.mid(slashIdx + 1, spaceIdx - (slashIdx + 1)).toString();
return res;
}
bool AttributeInfo::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::access), int(access));
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::typeName), typeName);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isReadonly), isReadonly);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isList), isList);
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, comments);
cont = cont && self.invokeVisitorOnField(visitor, Fields::annotations, annotations);
return cont;
}
Path AttributeInfo::addAnnotation(const Path &selfPathFromOwner, const QmlObject &annotation,
QmlObject **aPtr)
{
return appendUpdatableElementInQList(selfPathFromOwner.withField(Fields::annotations), annotations,
annotation, aPtr);
}
void AttributeInfo::updatePathFromOwner(const Path &newPath)
{
Path base = newPath.withField(Fields::annotations);
updatePathFromOwnerQList(annotations, newPath.withField(Fields::annotations));
}
bool EnumDecl::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = CommentableDomElement::iterateDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name());
cont = cont && self.invokeVisitorOnField(visitor, Fields::values, m_values);
cont = cont && self.invokeVisitorOnField(visitor, Fields::annotations, m_annotations);
return cont;
}
void EnumDecl::updatePathFromOwner(const Path &newPath)
{
DomElement::updatePathFromOwner(newPath);
updatePathFromOwnerQList(m_annotations, newPath.withField(Fields::annotations));
}
void EnumDecl::setAnnotations(const QList<QmlObject> &annotations)
{
m_annotations = annotations;
}
Path EnumDecl::addAnnotation(const QmlObject &annotation, QmlObject **aPtr)
{
return appendUpdatableElementInQList(pathFromOwner().withField(Fields::annotations), m_annotations,
annotation, aPtr);
}
void EnumDecl::writeOut(const DomItem &self, OutWriter &ow) const
{
const auto fLoc = FileLocations::treeOf(self);
ow.writeRegion(fLoc, EnumKeywordRegion)
.ensureSpace()
.writeRegion(fLoc, IdentifierRegion, name())
.ensureSpace()
.writeRegion(fLoc, LeftBraceRegion);
const auto values = self.field(Fields::values).values();
for (const auto &value : values)
value.writeOut(ow);
ow.ensureNewline().writeRegion(fLoc, RightBraceRegion);
}
bool PropertyInfo::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::propertyDefs),
propertyDefs);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::bindings), bindings);
return cont;
}
BindingValue::BindingValue() : kind(BindingValueKind::Empty) { }
BindingValue::BindingValue(const QmlObject &o) : kind(BindingValueKind::Object)
{
new (&object) QmlObject(o);
}
BindingValue::BindingValue(const std::shared_ptr<ScriptExpression> &o)
: kind(BindingValueKind::ScriptExpression)
{
new (&scriptExpression) std::shared_ptr<ScriptExpression>(o);
}
BindingValue::BindingValue(const QList<QmlObject> &l) : kind(BindingValueKind::Array)
{
new (&array) QList<QmlObject>(l);
}
BindingValue::~BindingValue()
{
clearValue();
}
BindingValue::BindingValue(const BindingValue &o) : kind(o.kind)
{
switch (o.kind) {
case BindingValueKind::Empty:
break;
case BindingValueKind::Object:
new (&object) QmlObject(o.object);
break;
case BindingValueKind::ScriptExpression:
new (&scriptExpression) std::shared_ptr<ScriptExpression>(o.scriptExpression);
break;
case BindingValueKind::Array:
new (&array) QList<QmlObject>(o.array);
}
}
BindingValue &BindingValue::operator=(const BindingValue &o)
{
clearValue();
kind = o.kind;
switch (o.kind) {
case BindingValueKind::Empty:
break;
case BindingValueKind::Object:
new (&object) QmlObject(o.object);
break;
case BindingValueKind::ScriptExpression:
new (&scriptExpression) std::shared_ptr<ScriptExpression>(o.scriptExpression);
break;
case BindingValueKind::Array:
new (&array) QList<QmlObject>(o.array);
}
return *this;
}
DomItem BindingValue::value(const DomItem &binding) const
{
switch (kind) {
case BindingValueKind::Empty:
break;
case BindingValueKind::Object:
return binding.copy(&object);
case BindingValueKind::ScriptExpression:
return binding.subOwnerItem(PathEls::Field(Fields::value), scriptExpression);
case BindingValueKind::Array:
return binding.subListItem(List::fromQListRef<QmlObject>(
binding.pathFromOwner().withField(u"value"), array,
[](const DomItem &self, const PathEls::PathComponent &, const QmlObject &obj) {
return self.copy(&obj);
}));
}
return DomItem();
}
void BindingValue::updatePathFromOwner(const Path &newPath)
{
switch (kind) {
case BindingValueKind::Empty:
break;
case BindingValueKind::Object:
object.updatePathFromOwner(newPath);
break;
case BindingValueKind::ScriptExpression:
break;
case BindingValueKind::Array:
updatePathFromOwnerQList(array, newPath);
break;
}
}
void BindingValue::clearValue()
{
switch (kind) {
case BindingValueKind::Empty:
break;
case BindingValueKind::Object:
object.~QmlObject();
break;
case BindingValueKind::ScriptExpression:
scriptExpression.~shared_ptr();
break;
case BindingValueKind::Array:
array.~QList<QmlObject>();
break;
}
kind = BindingValueKind::Empty;
}
ScriptExpression::ScriptExpression(QStringView code, const std::shared_ptr<QQmlJS::Engine> &engine,
AST::Node *ast, const std::shared_ptr<AstComments> &comments,
ExpressionType expressionType, const SourceLocation &localOffset)
: OwningItem(),
m_expressionType(expressionType),
m_code(code),
m_engine(engine),
m_ast(ast),
m_astComments(comments),
m_localOffset(localOffset)
{
if (m_expressionType == ExpressionType::BindingExpression)
if (AST::ExpressionStatement *exp = AST::cast<AST::ExpressionStatement *>(m_ast))
m_ast = exp->expression;
Q_ASSERT(m_astComments);
}
ScriptExpression::ScriptExpression(const ScriptExpression &e) : OwningItem(e)
{
QMutexLocker l(mutex());
m_expressionType = e.m_expressionType;
m_engine = e.m_engine;
m_ast = e.m_ast;
if (m_codeStr.isEmpty()) {
m_code = e.m_code;
} else {
m_codeStr = e.m_codeStr;
m_code = m_codeStr;
}
m_localOffset = e.m_localOffset;
m_astComments = e.m_astComments;
}
bool ScriptExpression::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = OwningItem::iterateDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::code), code());
cont = cont && self.invokeVisitorOnLazyField(
visitor, Fields::localOffset,
[this]() { return sourceLocationToQCborValue(localOffset()); },
ConstantData::Options::MapIsMap);
cont = cont && self.invokeVisitorOnLazyField(visitor, Fields::astRelocatableDump, [this]() {
return astRelocatableDump();
});
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::expressionType),
int(expressionType()));
if (m_element) {
cont = cont && visitor(PathEls::Field(Fields::scriptElement), [this, &self]() {
return self.subScriptElementWrapperItem(m_element);
});
}
return cont;
}
class FirstNodeVisitor : public VisitAll
{
public:
qsizetype minStart = 0;
qsizetype maxEnd = std::numeric_limits<qint32>::max(); // see also Lexer::checkFileLength().
AST::Node *firstNodeInRange = nullptr;
FirstNodeVisitor(qsizetype minStart, qsizetype maxEnd) : minStart(minStart), maxEnd(maxEnd) { }
bool preVisit(AST::Node *n) override
{
if (!VisitAll::uiKinds().contains(n->kind)) {
qsizetype start = n->firstSourceLocation().begin();
qsizetype end = n->lastSourceLocation().end();
if (!firstNodeInRange && minStart <= start && end <= maxEnd && start < end)
firstNodeInRange = n;
}
return !firstNodeInRange;
}
};
AST::Node *firstNodeInRange(AST::Node *n, qsizetype minStart = 0, qsizetype maxEnd = std::numeric_limits<qint32>::max())
{
FirstNodeVisitor visitor(minStart, maxEnd);
AST::Node::accept(n, &visitor);
return visitor.firstNodeInRange;
}
void ScriptExpression::setCode(const QString &code)
{
// TODO QTBUG-121933
if (code.isEmpty()) {
return;
}
m_codeStr = code;
m_code = QStringView(m_codeStr);
m_localOffset = SourceLocation();
m_localOffset.length = m_code.size();
m_engine = std::make_shared<QQmlJS::Engine>();
m_astComments = std::make_shared<AstComments>(m_engine);
m_ast = parse();
if (AST::Program *programPtr = AST::cast<AST::Program *>(m_ast)) {
m_ast = programPtr->statements;
}
if (auto *sList = AST::cast<AST::FormalParameterList *>(m_ast)) {
m_ast = sList->element;
}
if (m_expressionType != ExpressionType::FunctionBody) {
if (AST::StatementList *sList = AST::cast<AST::StatementList *>(m_ast)) {
if (!sList->next)
m_ast = sList->statement;
}
}
if (m_expressionType == ExpressionType::BindingExpression)
if (AST::ExpressionStatement *exp = AST::cast<AST::ExpressionStatement *>(m_ast))
m_ast = exp->expression;
CommentCollector collector;
collector.collectComments(m_engine, m_ast, m_astComments);
}
AST::Node *ScriptExpression::parse()
{
QQmlJS::Lexer lexer(m_engine.get());
// qmlMode enables QML specific things that plain JS doesn't have, for example type annotations.
const bool qmlMode = m_expressionType != ExpressionType::ESMCode
&& m_expressionType != ExpressionType::JSCode;
lexer.setCode(m_codeStr, /*lineno = */ 1, qmlMode);
QQmlJS::Parser parser(m_engine.get());
const bool parserSucceeded = m_expressionType == ExpressionType::ESMCode ? parser.parseModule()
: parser.parseScript();
if (!parserSucceeded) {
addErrorLocal(domParsingErrors().error(tr("Parsing of code failed")));
}
const auto messages = parser.diagnosticMessages();
for (const DiagnosticMessage &msg : messages) {
ErrorMessage err = domParsingErrors().errorMessage(msg);
err.location.offset -= m_localOffset.offset;
err.location.startLine -= m_localOffset.startLine;
if (err.location.startLine == 1)
err.location.startColumn -= m_localOffset.startColumn;
addErrorLocal(std::move(err));
}
return parser.rootNode();
}
void ScriptExpression::astDumper(const Sink &s, AstDumperOptions options) const
{
astNodeDumper(s, ast(), options, 1, 0, [this](SourceLocation astL) {
SourceLocation l = this->locationToLocal(astL);
return this->code().mid(l.offset, l.length);
});
}
QString ScriptExpression::astRelocatableDump() const
{
return dumperToString([this](const Sink &s) {
this->astDumper(s, AstDumperOption::NoLocations | AstDumperOption::SloppyCompare);
});
}
void ScriptExpression::writeOut(const DomItem &, OutWriter &lw) const
{
reformatAst(lw, this);
}
QStringView ScriptExpression::loc2Str(const SourceLocation &astL) const
{
SourceLocation l = this->locationToLocal(astL); // use engine->code() instead?
return this->code().mid(l.offset, l.length);
}
SourceLocation ScriptExpression::globalLocation(const DomItem &self) const
{
if (const FileLocations::Tree tree = FileLocations::treeOf(self)) {
return FileLocations::region(tree, MainRegion);
}
return SourceLocation();
}
bool PropertyDefinition::isParametricType() const
{
return typeName.contains(QChar(u'<'));
}
void PropertyDefinition::writeOut(const DomItem &self, OutWriter &lw) const
{
lw.ensureNewline();
const auto fLoc = FileLocations::treeOf(self);
if (isDefaultMember)
lw.writeRegion(fLoc, DefaultKeywordRegion).ensureSpace();
if (isVirtual)
lw.writeRegion(fLoc, VirtualKeywordRegion).ensureSpace();
if (isOverride)
lw.writeRegion(fLoc, OverrideKeywordRegion).ensureSpace();
if (isFinal)
lw.writeRegion(fLoc, FinalKeywordRegion).ensureSpace();
if (isRequired)
lw.writeRegion(fLoc, RequiredKeywordRegion).ensureSpace();
if (isReadonly)
lw.writeRegion(fLoc, ReadonlyKeywordRegion).ensureSpace();
if (!typeName.isEmpty()) {
lw.writeRegion(fLoc, PropertyKeywordRegion).ensureSpace();
lw.writeRegion(fLoc, TypeIdentifierRegion, typeName).ensureSpace();
}
lw.writeRegion(fLoc, IdentifierRegion, name);
}
bool MethodInfo::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = AttributeInfo::iterateDirectSubpaths(self, visitor);
cont = cont && self.invokeVisitorOnField(visitor, Fields::parameters, parameters);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::methodType),
int(methodType));
if (methodType == MethodType::Method) {
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isConstructor),
isConstructor);
}
if (returnType)
cont = cont && visitor(PathEls::Field(Fields::returnType), [this, &self]() {
return self.subOwnerItem(PathEls::Field(Fields::returnType), returnType);
});
if (body)
cont = cont && visitor(PathEls::Field(Fields::body), [this, &self]() {
return self.subOwnerItem(PathEls::Field(Fields::body), body);
});
return cont;
}
void MethodInfo::writeOutArguments(const DomItem &self, OutWriter &ow) const
{
if (parameters.isEmpty() && methodType == MethodType::Signal)
return;
const auto fLoc = FileLocations::treeOf(self);
ow.writeRegion(fLoc, LeftParenthesisRegion);
bool first = true;
for (const DomItem &arg : self.field(Fields::parameters).values()) {
if (first) {
first = false;
} else {
const auto fLocArg = FileLocations::treeOf(arg);
ow.writeRegion(fLocArg, CommaTokenRegion).ensureSpace();
}
arg.writeOut(ow);
}
ow.writeRegion(fLoc, RightParenthesisRegion);
}
void MethodInfo::writeOutReturnType(const DomItem &self, OutWriter &ow) const
{
if (typeName.isEmpty())
return;
const auto fLoc = FileLocations::treeOf(self);
ow.writeRegion(fLoc, ColonTokenRegion);
ow.ensureSpace();
ow.writeRegion(fLoc, TypeIdentifierRegion, typeName);
}
void MethodInfo::writeOutBody(const DomItem &self, OutWriter &ow) const
{
const auto fLoc = FileLocations::treeOf(self);
ow.ensureSpace().writeRegion(fLoc, LeftBraceRegion);
if (DomItem b = self.field(Fields::body)) {
ow.ensureNewline();
b.writeOut(ow);
}
ow.ensureNewline().writeRegion(fLoc, RightBraceRegion);
}
void MethodInfo::writeOut(const DomItem &self, OutWriter &ow) const
{
const auto fLoc = FileLocations::treeOf(self);
if (methodType == MethodType::Signal) {
ow.writeRegion(fLoc, SignalKeywordRegion).ensureSpace();
} else {
ow.writeRegion(fLoc, FunctionKeywordRegion);
if (isGenerator)
ow.writeRegion(fLoc, StarTokenRegion);
ow.ensureSpace();
}
ow.writeRegion(fLoc, IdentifierRegion, name);
writeOutArguments(self, ow);
if (methodType == MethodType::Signal) {
// signal doesn't have returnType or body
return;
}
writeOutReturnType(self, ow);
writeOutBody(self, ow);
}
QString MethodInfo::signature(const DomItem &self) const
{
QString resultStr;
QTextStream res(&resultStr);
LineWriter lw([&res](QStringView s) { res << s; }, QLatin1String("*testStream*"));
OutWriter ow(lw);
ow.indentNextlines = true;
ow.skipComments = true;
writeOutArguments(self, ow);
writeOutReturnType(self, ow);
lw.eof(false);
res.flush();
return resultStr.simplified();
}
bool MethodParameter::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name);
if (!typeName.isEmpty()) {
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::typeName), typeName);
}
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isPointer), isPointer);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isReadonly), isReadonly);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::isList), isList);
cont = cont && self.invokeVisitorOnField(visitor, Fields::defaultValue, defaultValue);
cont = cont && self.invokeVisitorOnField(visitor, Fields::value, value);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::preCode),
u"function f("_s);
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::postCode), u") {}"_s);
if (!annotations.isEmpty())
cont = cont && self.invokeVisitorOnField(visitor, Fields::annotations, annotations);
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, comments);
return cont;
}
void MethodParameter::writeOut(const DomItem &self, OutWriter &ow) const
{
if (typeAnnotationStyle == MethodParameter::TypeAnnotationStyle::Prefix) {
writeOutSignal(self, ow);
return;
}
if (!name.isEmpty()) {
const auto fLoc = FileLocations::treeOf(self);
if (isRestElement)
ow.writeRegion(fLoc, EllipsisTokenRegion);
ow.writeRegion(fLoc, IdentifierRegion, name);
if (!typeName.isEmpty())
ow.writeRegion(fLoc, ColonTokenRegion)
.ensureSpace()
.writeRegion(fLoc, TypeIdentifierRegion, typeName);
if (defaultValue) {
ow.ensureSpace().writeRegion(fLoc, EqualTokenRegion).ensureSpace();
self.subOwnerItem(PathEls::Field(Fields::defaultValue), defaultValue).writeOut(ow);
}
} else {
if (value) {
self.subOwnerItem(PathEls::Field(Fields::value), value).writeOut(ow);
}
}
}
void MethodParameter::writeOutSignal(const DomItem &self, OutWriter &ow) const
{
self.writeOutPre(ow);
const auto fLoc = FileLocations::treeOf(self);
if (!typeName.isEmpty())
ow.writeRegion(fLoc, TypeIdentifierRegion, typeName).ensureSpace();
ow.writeRegion(fLoc, IdentifierRegion, name);
self.writeOutPost(ow);
}
void Pragma::writeOut(const DomItem &self, OutWriter &ow) const
{
const auto fLoc = FileLocations::treeOf(self);
ow.ensureNewline();
ow.writeRegion(fLoc, PragmaKeywordRegion)
.ensureSpace()
.writeRegion(fLoc, IdentifierRegion, name);
bool isFirst = true;
for (const auto &value : values) {
if (isFirst) {
isFirst = false;
ow.writeRegion(fLoc, ColonTokenRegion).ensureSpace();
ow.writeRegion(fLoc, PragmaValuesRegion, value);
continue;
}
ow.writeRegion(fLoc, CommaTokenRegion).ensureSpace();
ow.writeRegion(fLoc, PragmaValuesRegion, value);
}
ow.ensureNewline();
}
bool EnumItem::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
bool cont = true;
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::name), name());
cont = cont && self.invokeVisitorOnValue(visitor, PathEls::Field(Fields::value), value());
cont = cont && self.invokeVisitorOnField(visitor, Fields::comments, m_comments);
return cont;
}
void EnumItem::writeOut(const DomItem &self, OutWriter &ow) const
{
const auto fLoc = FileLocations::treeOf(self);
index_type myIndex = self.pathFromOwner().last().headIndex();
if (myIndex != 0)
ow.writeRegion(fLoc, CommaTokenRegion);
ow.ensureNewline();
ow.writeRegion(fLoc, IdentifierRegion, name());
if (m_valueKind == ValueKind::ExplicitValue) {
QString v = QString::number(value(), 'f', 0);
if (abs(value() - v.toDouble()) > 1.e-10)
v = QString::number(value());
ow.ensureSpace()
.writeRegion(fLoc, EqualTokenRegion)
.ensureSpace()
.writeRegion(fLoc, EnumValueRegion, v);
}
}
QmlUri QmlUri::fromString(const QString &str)
{
if (str.startsWith(u'"'))
return fromDirectoryString(str.mid(1, str.size() - 2)
.replace(u"\\\""_s, u"\""_s)
.replace(u"\\\\"_s, u"\\"_s));
else
return fromUriString(str);
}
QmlUri QmlUri::fromUriString(const QString &str)
{
QRegularExpression moduleUriRe(QLatin1String(R"(\A\w+(?:\.\w+)*\Z)"));
return QmlUri((moduleUriRe.match(str).hasMatch() ? Kind::ModuleUri : Kind::Invalid), str);
}
QmlUri QmlUri::fromDirectoryString(const QString &str)
{
QUrl url(str);
if (url.isValid() && url.scheme().size() > 1)
return QmlUri(url);
if (!str.isEmpty()) {
QFileInfo path(str);
return QmlUri((path.isRelative() ? Kind::RelativePath : Kind::AbsolutePath), str);
}
return {};
}
bool QmlUri::isValid() const
{
return m_kind != Kind::Invalid;
}
bool QmlUri::isDirectory() const
{
switch (m_kind) {
case Kind::Invalid:
case Kind::ModuleUri:
break;
case Kind::DirectoryUrl:
case Kind::RelativePath:
case Kind::AbsolutePath:
return true;
}
return false;
}
bool QmlUri::isModule() const
{
return m_kind == Kind::ModuleUri;
}
QString QmlUri::moduleUri() const
{
if (m_kind == Kind::ModuleUri)
return std::get<QString>(m_value);
return QString();
}
QString QmlUri::localPath() const
{
switch (m_kind) {
case Kind::Invalid:
case Kind::ModuleUri:
break;
case Kind::DirectoryUrl: {
const QUrl &url = std::get<QUrl>(m_value);
if (url.scheme().compare(u"file", Qt::CaseInsensitive) == 0)
return url.path();
break;
}
case Kind::RelativePath:
case Kind::AbsolutePath:
return std::get<QString>(m_value);
}
return QString();
}
QString QmlUri::absoluteLocalPath(const QString &basePath) const
{
switch (m_kind) {
case Kind::Invalid:
case Kind::ModuleUri:
break;
case Kind::DirectoryUrl: {
const QUrl &url = std::get<QUrl>(m_value);
if (url.scheme().compare(u"file", Qt::CaseInsensitive) == 0)
return url.path();
break;
}
case Kind::RelativePath: {
if (!basePath.isEmpty())
return QDir(basePath).filePath(std::get<QString>(m_value));
break;
}
case Kind::AbsolutePath:
return std::get<QString>(m_value);
}
return QString();
}
QUrl QmlUri::directoryUrl() const
{
if (m_kind == Kind::DirectoryUrl)
return std::get<QUrl>(m_value);
return QUrl {};
}
QString QmlUri::directoryString() const
{
switch (m_kind) {
case Kind::Invalid:
case Kind::ModuleUri:
break;
case Kind::DirectoryUrl:
return std::get<QUrl>(m_value).toString(); // set formatting? options?
case Kind::RelativePath:
case Kind::AbsolutePath:
return std::get<QString>(m_value);
}
return QString();
}
QString QmlUri::toString() const
{
switch (m_kind) {
case Kind::Invalid:
break;
case Kind::ModuleUri:
return std::get<QString>(m_value);
case Kind::DirectoryUrl:
case Kind::RelativePath:
case Kind::AbsolutePath:
return u"\""_s + directoryString().replace(u'\\', u"\\\\"_s).replace(u'"', u"\\\""_s)
+ u"\""_s;
}
return QString();
}
QmlUri::Kind QmlUri::kind() const
{
return m_kind;
}
void ScriptExpression::setScriptElement(const ScriptElementVariant &p)
{
m_element = p;
}
} // end namespace Dom
} // end namespace QQmlJS
QT_END_NAMESPACE
#include "moc_qqmldomelements_p.cpp"