// 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.dvWrapField(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.dvValueField(visitor, Fields::name, name());
    cont = cont && self.dvWrapField(visitor, Fields::enumerations, m_enumerations);
    cont = cont && self.dvWrapField(visitor, Fields::objects, m_objects);
    cont = cont && self.dvValueField(visitor, Fields::isSingleton, isSingleton());
    cont = cont && self.dvValueField(visitor, Fields::isCreatable, isCreatable());
    cont = cont && self.dvValueField(visitor, Fields::isComposite, isComposite());
    cont = cont && self.dvValueField(visitor, Fields::attachedTypeName, attachedTypeName());
    cont = cont && self.dvReferenceField(visitor, Fields::attachedType, attachedTypePath(self));
    return cont;
}

DomItem Component::field(const DomItem &self, QStringView name) const
{
    if (name == Fields::name)
        return self.wrapField(Fields::name, m_name);
    if (name == Fields::objects)
        return self.wrapField(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.dvWrapField(visitor, Fields::ids, m_ids);
    cont = cont && self.dvValueLazyField(visitor, Fields::subComponents, [this, &self]() {
        return this->subComponents(self);
    });
    if (m_nameIdentifiers) {
        cont = cont && self.dvItemField(visitor, 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
        lw.ensureNewline()
                .writeRegion(ComponentKeywordRegion)
                .ensureSpace()
                .writeRegion(IdentifierRegion, name().split(QLatin1Char('.')).last())
                .writeRegion(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.dvWrapField(visitor, Fields::majorVersion, majorVersion);
    cont = cont && self.dvWrapField(visitor, Fields::minorVersion, minorVersion);
    cont = cont && self.dvValueField(visitor, Fields::isLatest, isLatest());
    cont = cont && self.dvValueField(visitor, Fields::isValid, isValid());
    cont = cont && self.dvValueLazyField(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.dvValueField(visitor, Fields::uri, uri.toString());
    cont = cont && self.dvWrapField(visitor, Fields::version, version);
    if (!importId.isEmpty())
        cont = cont && self.dvValueField(visitor, Fields::importId, importId);
    if (implicit)
        cont = cont && self.dvValueField(visitor, Fields::implicit, implicit);
    cont = cont && self.dvWrapField(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 elLoc = FileLocations::treeOf(self);

    quint32 start = elLoc->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(ImportTokenRegion).ensureSpace();
    ow.writeRegion(ImportUriRegion, uri.toString());
    if (uri.isModule()) {
        QString vString = version.stringValue();
        if (!vString.isEmpty())
            ow.ensureSpace().writeRegion(VersionRegion, vString);
    }
    if (!importId.isEmpty()) {
        ow.ensureSpace().writeRegion(AsTokenRegion).ensureSpace().writeRegion(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.dvValueField(visitor, Fields::name, name);
    cont = cont && self.dvReferenceField(visitor, Fields::referredObject, referredObjectPath);
    cont = cont && self.dvWrapField(visitor, Fields::comments, comments);
    cont = cont && self.dvWrapField(visitor, Fields::annotations, annotations);
    cont = cont && self.dvWrapField(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.dvValueField(visitor, Fields::idStr, idStr());
    cont = cont && self.dvValueField(visitor, Fields::name, name());
    if (!prototypePaths().isEmpty())
        cont = cont && self.dvReferencesField(visitor, Fields::prototypes, m_prototypePaths);
    if (nextScopePath())
        cont = cont && self.dvReferenceField(visitor, Fields::nextScope, nextScopePath());
    cont = cont && self.dvWrapField(visitor, Fields::propertyDefs, m_propertyDefs);
    cont = cont && self.dvWrapField(visitor, Fields::bindings, m_bindings);
    cont = cont && self.dvWrapField(visitor, Fields::methods, m_methods);
    cont = cont && self.dvWrapField(visitor, Fields::children, m_children);
    cont = cont && self.dvWrapField(visitor, Fields::annotations, m_annotations);
    cont = cont && self.dvItemField(visitor, 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 && self.dvItemField(visitor, 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.dvValueLazyField(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.wrapField(Fields::methods, m_methods);
    if (name == Fields::bindings)
        return self.wrapField(Fields::bindings, m_bindings);
    if (name == Fields::comments)
        return CommentableDomElement::field(self, name);
    if (name == Fields::children)
        return self.wrapField(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.wrapField(Fields::annotations, m_annotations);
    if (name == Fields::propertyDefs)
        return self.wrapField(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, 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);
        if (myId)
            myId.writeOutPre(ow);
        ow.ensureNewline()
                .writeRegion(IdTokenRegion)
                .writeRegion(IdColonTokenRegion)
                .ensureSpace()
                .writeRegion(IdNameRegion, idStr());
        if (ow.lineWriter.options().attributesSequence
            == LineWriterOptions::AttributesSequence::Normalize) {
            ow.ensureNewline(2);
        }
        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(const DomItem &self, OutWriter &ow, const DomItem &component,
                                   const QString &code) const
{
    const QList<std::pair<SourceLocation, DomItem>> attribs = orderOfAttributes(self, component);
    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) {
                ow.writeRegion(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(LeftBraceRegion).writeRegion(RightBraceRegion);
                }
                b.writeOutPost(ow);
            }
        } else {
            el.second.writeOut(ow);
        }
        ow.ensureNewline();
    }
}

void QmlObject::writeOutSortedEnumerations(const DomItem &component, OutWriter &ow) const
{
    const auto descs = component.field(Fields::enumerations).values();
    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
{
    DomItem propertyDefs = field(self, Fields::propertyDefs);
    DomItem bindings = field(self, Fields::bindings);

    for (const QString &defName : propertyDefs.sortedKeys()) {
        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) {
                ow.writeRegion(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(LeftBraceRegion).writeRegion(RightBraceRegion);
                }
                b.writeOutPost(ow);
            }
        }
    }
}

static std::pair<QList<DomItem>, QList<DomItem>> splitSignalsAndMethods(const DomItem &methods)
{
    QList<DomItem> signalList, methodList;
    const auto fields = methods.values();
    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)
{
    QList<DomItem> normalBindings, signalHandlers, delayedBindings;
    for (const auto &bName : bindings.sortedKeys()) {
        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
{
    int spacerId = 0;
    quint32 counter = ow.counter();

    if (component)
        writeOutSortedEnumerations(component, ow);

    if (counter != ow.counter() || !idStr().isEmpty())
        spacerId = ow.addNewlinesAutospacerCallback(2);

    QSet<QString> mergedDefBinding;
    writeOutSortedPropertyDefinition(self, ow, mergedDefBinding);

    ow.removeTextAddCallback(spacerId);
    if (counter != ow.counter())
        spacerId = ow.addNewlinesAutospacerCallback(2);

    const auto [signalList, methodList] = splitSignalsAndMethods(field(self, Fields::methods));
    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);
    const auto [normalBindings, signalHandlers, delayedBindings] =
            splitBindings(bindings, mergedDefBinding);

    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);
    }
    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);
    ow.writeRegion(IdentifierRegion, name());
    if (!onTarget.isEmpty()) {
        ow.ensureSpace().writeRegion(OnTokenRegion).ensureSpace().writeRegion(OnTargetRegion,
                                                                              onTarget);
    }
    ow.ensureSpace();
    ow.writeRegion(LeftBraceRegion);
    int baseIndent = ow.increaseIndent();

    // *always* put id first
    writeOutId(self, ow);

    DomItem component;
    if (isRootObject)
        component = self.containingObject();
    if (ow.lineWriter.options().attributesSequence
        == LineWriterOptions::AttributesSequence::Preserve) {
        QString code;
        if (std::shared_ptr<QmlFile> qmlFilePtr = self.ownerAs<QmlFile>())
            code = qmlFilePtr->code();
        writeOutAttributes(self, ow, component, code);
    } else {
        writeOutSortedAttributes(self, ow, component);
    }
    ow.decreaseIndent(1, baseIndent);
    ow.writeRegion(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, 0,
                      Binding::preCodeForName(name), Binding::postCodeForName(name))),
              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.dvValueField(visitor, Fields::name, m_name);
    cont = cont && self.dvValueField(visitor, Fields::isSignalHandler, isSignalHandler());
    if (!m_value)
        cont = cont && visitor(PathEls::Field(Fields::value), []() { return DomItem(); });
    else
        cont = cont && self.dvItemField(visitor, Fields::value, [this, &self]() {
            return m_value->value(self);
        });
    cont = cont && self.dvValueField(visitor, Fields::bindingType, int(m_bindingType));
    cont = cont && self.dvWrapField(visitor, Fields::comments, m_comments);
    cont = cont && self.dvValueLazyField(visitor, Fields::preCode, [this]() {
        return this->preCode();
    });
    cont = cont && self.dvValueLazyField(visitor, Fields::postCode, [this]() {
        return this->postCode();
    });
    if (m_bindingIdentifiers) {
        cont = cont && self.dvItemField(visitor, Fields::bindingIdentifiers, [this, &self]() {
            return self.subScriptElementWrapperItem(m_bindingIdentifiers);
        });
    }
    cont = cont && self.dvWrapField(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
{
    lw.ensureNewline();
    if (m_bindingType == BindingType::Normal) {
        lw.writeRegion(IdentifierRegion, name());
        lw.writeRegion(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);
    switch (valueKind()) {
    case BindingValueKind::Empty:
        qCWarning(writeOutLog()) << "Writing of empty binding " << name();
        lw.writeRegion(LeftBraceRegion);
        lw.writeRegion(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;
    }
}

bool QmltypesComponent::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = Component::iterateDirectSubpaths(self, visitor);
    cont = cont && self.dvWrapField(visitor, Fields::exports, m_exports);
    cont = cont && self.dvValueField(visitor, Fields::metaRevisions, m_metaRevisions);
    if (!fileName().isEmpty())
        cont = cont && self.dvValueField(visitor, Fields::fileName, fileName()); // remove?
    cont = cont && self.dvValueField(visitor, Fields::interfaceNames, m_interfaceNames);
    cont = cont && self.dvValueField(visitor, Fields::hasCustomParser, m_hasCustomParser);
    cont = cont && self.dvValueField(visitor, Fields::valueTypeName, m_valueTypeName);
    cont = cont && self.dvValueField(visitor, Fields::extensionTypeName, m_extensionTypeName);
    cont = cont && self.dvValueField(visitor, Fields::accessSemantics, int(m_accessSemantics));
    return cont;
}

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.dvValueField(visitor, Fields::name, name);
    cont = cont && self.dvValueField(visitor, Fields::access, int(access));
    cont = cont && self.dvValueField(visitor, Fields::typeName, typeName);
    cont = cont && self.dvValueField(visitor, Fields::isReadonly, isReadonly);
    cont = cont && self.dvValueField(visitor, Fields::isList, isList);
    cont = cont && self.dvWrapField(visitor, Fields::comments, comments);
    cont = cont && self.dvWrapField(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.dvValueField(visitor, Fields::name, name());
    cont = cont && self.dvWrapField(visitor, Fields::values, m_values);
    cont = cont && self.dvWrapField(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
{
    ow.writeRegion(EnumKeywordRegion)
            .ensureSpace()
            .writeRegion(IdentifierRegion, name())
            .ensureSpace()
            .writeRegion(LeftBraceRegion);
    int iLevel = ow.increaseIndent(1);
    const auto values = self.field(Fields::values).values();
    for (const auto &value : values)
        value.writeOut(ow);
    ow.decreaseIndent(1, iLevel);
    ow.ensureNewline().writeRegion(RightBraceRegion);
}

QList<Path> ImportScope::allSources(const DomItem &self) const
{
    DomItem top = self.top();
    DomItem env = top.environment();
    Path selfPath = self.canonicalPath().withField(Fields::allSources);
    RefCacheEntry cached = (env ? RefCacheEntry::forPath(env, selfPath) : RefCacheEntry());
    if (cached.cached == RefCacheEntry::Cached::All)
        return cached.canonicalPaths;
    QList<Path> res;
    QSet<Path> knownPaths;
    QList<Path> toDo(m_importSourcePaths.rbegin(), m_importSourcePaths.rend());
    while (!toDo.isEmpty()) {
        Path pNow = toDo.takeLast();
        if (knownPaths.contains(pNow))
            continue;
        knownPaths.insert(pNow);
        res.append(pNow);
        DomItem sourceBase = top.path(pNow);
        for (const DomItem &autoExp : sourceBase.field(Fields::autoExports).values()) {
            if (const ModuleAutoExport *autoExpPtr = autoExp.as<ModuleAutoExport>()) {
                Path newSource;
                if (autoExpPtr->inheritVersion) {
                    Version v = autoExpPtr->import.version;
                    DomItem sourceVersion = sourceBase.field(Fields::version);
                    if (const Version *sourceVersionPtr = sourceVersion.as<Version>()) {
                        if (v.majorVersion < 0)
                            v.majorVersion = sourceVersionPtr->majorVersion;
                        if (v.minorVersion < 0)
                            v.minorVersion = sourceVersionPtr->minorVersion;
                    } else {
                        qWarning() << "autoExport with inherited version " << autoExp
                                   << " but missing version in source" << pNow;
                    }
                    Import toImport(autoExpPtr->import.uri, v);
                    newSource = toImport.importedPath();
                } else {
                    newSource = autoExpPtr->import.importedPath();
                }
                if (newSource && !knownPaths.contains(newSource))
                    toDo.append(newSource);
            } else {
                qWarning() << "expected ModuleAutoExport not " << autoExp.internalKindStr()
                           << "looking up autoExports of" << sourceBase;
                Q_ASSERT(false);
            }
        }
    }
    if (env)
        RefCacheEntry::addForPath(env, selfPath, RefCacheEntry { RefCacheEntry::Cached::All, res });
    return res;
}

bool ImportScope::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = true;
    cont = cont && self.dvReferencesField(visitor, Fields::importSources, m_importSourcePaths);
    cont = cont && self.dvItemField(visitor, Fields::allSources, [this, &self]() -> DomItem {
        return self.subListItem(List::fromQList<Path>(
                self.pathFromOwner().withField(Fields::allSources), allSources(self),
                [](const DomItem &list, const PathEls::PathComponent &p, const Path &el) {
                    return list.subDataItem(p, el.toString());
                }));
    });
    cont = cont && self.dvWrapField(visitor, Fields::qualifiedImports, m_subImports);
    cont = cont && self.dvItemField(visitor, Fields::imported, [this, &self]() -> DomItem {
        return self.subMapItem(Map(
                self.pathFromOwner().withField(Fields::imported),
                [this, &self](const DomItem &map, const QString &key) {
                    return map.subListItem(List::fromQList<DomItem>(
                            map.pathFromOwner().withKey(key), importedItemsWithName(self, key),
                            [](const DomItem &, const PathEls::PathComponent &, const DomItem &el) {
                                return el;
                            }));
                },
                [this, &self](const DomItem &) { return this->importedNames(self); },
                QLatin1String("List<Export>")));
    });
    return cont;
}

bool PropertyInfo::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = true;
    cont = cont && self.dvValueField(visitor, Fields::propertyDefs, propertyDefs);
    cont = cont && self.dvValueField(visitor, 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,
        SourceLocation localOffset, int derivedFrom, QStringView preCode, QStringView postCode)
    : OwningItem(derivedFrom),
      m_expressionType(expressionType),
      m_code(code),
      m_preCode(preCode),
      m_postCode(postCode),
      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;
}

std::shared_ptr<ScriptExpression> ScriptExpression::copyWithUpdatedCode(
        const DomItem &self, const QString &code) const
{
    std::shared_ptr<ScriptExpression> copy = makeCopy(self);
    DomItem container = self.containingObject();
    QString preCodeStr = container.field(Fields::preCode).value().toString(m_preCode.toString());
    QString postCodeStr = container.field(Fields::postCode).value().toString(m_postCode.toString());
    copy->setCode(code, preCodeStr, postCodeStr);
    return copy;
}

bool ScriptExpression::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = OwningItem::iterateDirectSubpaths(self, visitor);
    cont = cont && self.dvValueField(visitor, Fields::code, code());
    if (!preCode().isEmpty())
        cont = cont
                && self.dvValueField(visitor, Fields::preCode, preCode(),
                                     ConstantData::Options::MapIsMap);
    if (!postCode().isEmpty())
        cont = cont
                && self.dvValueField(visitor, Fields::postCode, postCode(),
                                     ConstantData::Options::MapIsMap);
    cont = cont
            && self.dvValueLazyField(
                    visitor, Fields::localOffset,
                    [this]() { return sourceLocationToQCborValue(localOffset()); },
                    ConstantData::Options::MapIsMap);
    cont = cont && self.dvValueLazyField(visitor, Fields::astRelocatableDump, [this]() {
        return astRelocatableDump();
    });
    cont = cont && self.dvValueField(visitor, Fields::expressionType, int(expressionType()));
    if (m_element) {
        cont = cont && self.dvItemField(visitor, 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, const QString &preCode, const QString &postCode)
{
    // TODO QTBUG-121933
    m_codeStr = code;
    QString resolvedPreCode, resolvedPostCode;
    if (m_expressionType == ExpressionType::BindingExpression && preCode.isEmpty()) {
        resolvedPreCode = Binding::preCodeForName(u"binding");
        resolvedPostCode = Binding::postCodeForName(u"binding");
    } else {
        resolvedPreCode = preCode;
        resolvedPostCode = postCode;
    }
    if (!resolvedPreCode.isEmpty() || !resolvedPostCode.isEmpty())
        m_codeStr = resolvedPreCode + code + resolvedPostCode;
    m_code = QStringView(m_codeStr).mid(resolvedPreCode.size(), code.size());
    m_preCode = QStringView(m_codeStr).mid(0, resolvedPreCode.size());
    m_postCode = QStringView(m_codeStr).mid(
            resolvedPreCode.size() + code.size(), resolvedPostCode.size());
    m_engine = nullptr;
    m_ast = nullptr;
    m_localOffset = SourceLocation();
    if (!m_code.isEmpty()) {
        IndentInfo preChange(m_preCode, 4);
        m_localOffset.offset = m_preCode.size();
        m_localOffset.length = m_code.size();
        m_localOffset.startColumn = preChange.trailingString.size();
        m_localOffset.startLine = preChange.nNewlines;
        m_engine = std::make_shared<QQmlJS::Engine>();
        m_astComments = std::make_shared<AstComments>(m_engine);
        m_ast = parse(resolveParseMode());

        if (AST::Program *programPtr = AST::cast<AST::Program *>(m_ast)) {
            m_ast = programPtr->statements;
        }
        if (!m_preCode.isEmpty())
            m_ast = firstNodeInRange(m_ast, m_preCode.size(),
                                     m_preCode.size() + m_code.size());
        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(const ParseMode mode)
{
    QQmlJS::Lexer lexer(m_engine.get());
    lexer.setCode(m_codeStr, /*lineno = */ 1, /*qmlMode=*/mode == ParseMode::QML);
    QQmlJS::Parser parser(m_engine.get());
    const bool parserSucceeded = [mode, &parser]() {
        switch (mode) {
        case ParseMode::QML:
            return parser.parse();
        case ParseMode::JS:
            return parser.parseScript();
        case ParseMode::ESM:
            return parser.parseModule();
        default:
            Q_UNREACHABLE_RETURN(false);
        }
    }();
    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(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 &, OutWriter &lw) const
{
    lw.ensureNewline();
    if (isDefaultMember)
        lw.writeRegion(DefaultKeywordRegion).ensureSpace();
    if (isFinal)
        lw.writeRegion(FinalKeywordRegion).ensureSpace();
    if (isRequired)
        lw.writeRegion(RequiredKeywordRegion).ensureSpace();
    if (isReadonly)
        lw.writeRegion(ReadonlyKeywordRegion).ensureSpace();
    if (!typeName.isEmpty()) {
        lw.writeRegion(PropertyKeywordRegion).ensureSpace();
        lw.writeRegion(TypeIdentifierRegion, typeName).ensureSpace();
    }
    lw.writeRegion(IdentifierRegion, name);
}

bool MethodInfo::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = AttributeInfo::iterateDirectSubpaths(self, visitor);
    cont = cont && self.dvWrapField(visitor, Fields::parameters, parameters);
    cont = cont && self.dvValueField(visitor, Fields::methodType, int(methodType));
    if (!typeName.isEmpty())
        cont = cont && self.dvReferenceField(visitor, Fields::type, typePath(self));
    if (methodType == MethodType::Method) {
        cont = cont && self.dvValueField(visitor, Fields::preCode, preCode(self));
        cont = cont && self.dvValueField(visitor, Fields::postCode, postCode(self));
        cont = cont && self.dvValueField(visitor, Fields::isConstructor, isConstructor);
    }
    if (returnType)
        cont = cont && self.dvItemField(visitor, Fields::returnType, [this, &self]() {
            return self.subOwnerItem(PathEls::Field(Fields::returnType), returnType);
        });
    if (body)
        cont = cont && self.dvItemField(visitor, Fields::body, [this, &self]() {
            return self.subOwnerItem(PathEls::Field(Fields::body), body);
        });
    return cont;
}

QString MethodInfo::preCode(const DomItem &self) const
{
    QString res;
    LineWriter lw([&res](QStringView s) { res.append(s); }, QLatin1String("*preCode*"));
    OutWriter ow(lw);
    ow.indentNextlines = true;
    ow.skipComments = true;
    MockObject standinObj(self.pathFromOwner());
    DomItem standin = self.copy(&standinObj);
    ow.itemStart(standin);
    ow.writeRegion(FunctionKeywordRegion).ensureSpace().writeRegion(IdentifierRegion, name);
    bool first = true;
    ow.writeRegion(LeftParenthesisRegion);
    for (const MethodParameter &mp : parameters) {
        if (first) {
            first = false;
        } else {
            ow.writeRegion(CommaTokenRegion);
            ow.ensureSpace();
        }
        ow.write(mp.value->code());
    }
    ow.writeRegion(RightParenthesisRegion);
    ow.ensureSpace().writeRegion(LeftBraceRegion);
    ow.itemEnd();
    ow.eof();
    return res;
}

QString MethodInfo::postCode(const DomItem &) const
{
    return QLatin1String("\n}\n");
}

void MethodInfo::writeOutArguments(const DomItem &self, OutWriter &ow) const
{
    if (parameters.isEmpty() && methodType == MethodType::Signal)
        return;

    ow.writeRegion(LeftParenthesisRegion);
    bool first = true;
    for (const DomItem &arg : self.field(Fields::parameters).values()) {
        if (first)
            first = false;
        else
            ow.writeRegion(CommaTokenRegion).ensureSpace();
        arg.writeOut(ow);
    }
    ow.writeRegion(RightParenthesisRegion);
}

void MethodInfo::writeOutReturnType(OutWriter &ow) const
{
    if (typeName.isEmpty())
        return;

    ow.writeRegion(ColonTokenRegion);
    ow.ensureSpace();
    ow.writeRegion(TypeIdentifierRegion, typeName);
}

void MethodInfo::writeOutBody(const DomItem &self, OutWriter &ow) const
{
    ow.ensureSpace().writeRegion(LeftBraceRegion);
    int baseIndent = ow.increaseIndent();
    if (DomItem b = self.field(Fields::body)) {
        ow.ensureNewline();
        b.writeOut(ow);
    }
    ow.decreaseIndent(1, baseIndent);
    ow.ensureNewline().writeRegion(RightBraceRegion);
}

void MethodInfo::writeOut(const DomItem &self, OutWriter &ow) const
{
    if (methodType == MethodType::Signal) {
        ow.writeRegion(SignalKeywordRegion).ensureSpace();
    } else {
        ow.writeRegion(FunctionKeywordRegion).ensureSpace();
    }
    ow.writeRegion(IdentifierRegion, name);
    writeOutArguments(self, ow);
    if (methodType == MethodType::Signal) {
        // signal doesn't have returnType or body
        return;
    }
    writeOutReturnType(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;

    ow.itemStart(self);
    writeOutArguments(self, ow);

    writeOutReturnType(ow);

    ow.itemEnd();
    lw.eof(false);
    res.flush();
    return resultStr.simplified();
}

bool MethodParameter::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = true;
    cont = cont && self.dvValueField(visitor, Fields::name, name);
    if (!typeName.isEmpty()) {
        cont = cont
                && self.dvReferenceField(visitor, Fields::type, Paths::lookupTypePath(typeName));
        cont = cont && self.dvValueField(visitor, Fields::typeName, typeName);
    }
    cont = cont && self.dvValueField(visitor, Fields::isPointer, isPointer);
    cont = cont && self.dvValueField(visitor, Fields::isReadonly, isReadonly);
    cont = cont && self.dvValueField(visitor, Fields::isList, isList);
    cont = cont && self.dvWrapField(visitor, Fields::defaultValue, defaultValue);
    cont = cont && self.dvWrapField(visitor, Fields::value, value);

    cont = cont && self.dvValueField(visitor, Fields::preCode, u"function f("_s);
    cont = cont && self.dvValueField(visitor, Fields::postCode, u") {}"_s);

    if (!annotations.isEmpty())
        cont = cont && self.dvWrapField(visitor, Fields::annotations, annotations);
    cont = cont && self.dvWrapField(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()) {
        if (isRestElement)
            ow.writeRegion(EllipsisTokenRegion);
        ow.writeRegion(IdentifierRegion, name);
        if (!typeName.isEmpty())
            ow.writeRegion(ColonTokenRegion).ensureSpace().writeRegion(TypeIdentifierRegion, typeName);
        if (defaultValue) {
            ow.ensureSpace().writeRegion(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);
    if (!typeName.isEmpty())
        ow.writeRegion(TypeIdentifierRegion, typeName).ensureSpace();
    ow.writeRegion(IdentifierRegion, name);
    self.writeOutPost(ow);
}

void Pragma::writeOut(const DomItem &, OutWriter &ow) const
{
    ow.ensureNewline();
    ow.writeRegion(PragmaKeywordRegion).ensureSpace().writeRegion(IdentifierRegion, name);

    bool isFirst = true;
    for (const auto &value : values) {
        if (isFirst) {
            isFirst = false;
            ow.writeRegion(ColonTokenRegion).ensureSpace();
            ow.writeRegion(PragmaValuesRegion, value);
            continue;
        }

        ow.writeRegion(CommaTokenRegion).ensureSpace();
        ow.writeRegion(PragmaValuesRegion, value);
    }
    ow.ensureNewline();
}

bool EnumItem::iterateDirectSubpaths(const DomItem &self, DirectVisitor visitor) const
{
    bool cont = true;
    cont = cont && self.dvValueField(visitor, Fields::name, name());
    cont = cont && self.dvValueField(visitor, Fields::value, value());
    cont = cont && self.dvWrapField(visitor, Fields::comments, m_comments);
    return cont;
}

void EnumItem::writeOut(const DomItem &self, OutWriter &ow) const
{
    index_type myIndex = self.pathFromOwner().last().headIndex();
    if (myIndex != 0)
        ow.writeRegion(CommaTokenRegion);
    ow.ensureNewline();
    ow.writeRegion(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(EqualTokenRegion).ensureSpace().writeRegion(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"
