qqmldomastcreator_p.h

Go to the documentation of this file.

// 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
 
#ifndef QQMLDOMASTCREATOR_P_H
#define QQMLDOMASTCREATOR_P_H
 
//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
 
#include "qqmldomelements_p.h"
#include "qqmldomitem_p.h"
#include "qqmldompath_p.h"
#include "qqmldomtop_p.h"
#include "qqmldomscriptelements_p.h"
 
#include <QtQmlCompiler/private/qqmljsimportvisitor_p.h>
 
#include <QtQml/private/qqmljsastvisitor_p.h>
#include <memory>
#include <type_traits>
#include <variant>
 
QT_BEGIN_NAMESPACE
 
namespace QQmlJS {
namespace Dom {
 
class QQmlDomAstCreatorBase : public AST::Visitor
{
    Q_DECLARE_TR_FUNCTIONS(QQmlDomAstCreator)
public:
    using AST::Visitor::endVisit;
    using AST::Visitor::visit;
private:
 
    static constexpr const auto className = "QmlDomAstCreator";
 
    class DomValue
    {
    public:
        template<typename T>
        DomValue(const T &obj) : kind(T::kindValue), value(obj)
        {
        }
        DomType kind;
        std::variant<QmlObject, MethodInfo, QmlComponent, PropertyDefinition, Binding, EnumDecl,
                     EnumItem, ConstantData, Id>
                value;
    };
 
    class QmlStackElement
    {
    public:
        Path path;
        DomValue item;
        FileLocations::Tree fileLocations;
    };
 
    /*!
      \internal
      Contains a ScriptElementVariant, that can be used everywhere in the DOM representation, or a
      List that should always be inside of something else, e.g., that cannot be the root of the
      script element DOM representation.
 
      Also, it makes sure you do not mistreat a list as a regular script element and vice versa.
 
      The reason for this is that Lists can get pretty unintuitive, as a List could be a Block of
      statements or a list of variable declarations (let i = 3, j = 4, ...) or something completely
      different. Instead, always put lists inside named construct (BlockStatement,
      VariableDeclaration, ...).
     */
    class ScriptStackElement
    {
    public:
        template<typename T>
        static ScriptStackElement from(const T &obj)
        {
            if constexpr (std::is_same_v<T, ScriptElements::ScriptList>) {
                ScriptStackElement s{ ScriptElements::ScriptList::kindValue, obj };
                return s;
            } else {
                ScriptStackElement s{ obj->kind(), ScriptElementVariant::fromElement(obj) };
                return s;
            }
            Q_UNREACHABLE();
        }
 
        DomType kind;
        using Variant = std::variant<ScriptElementVariant, ScriptElements::ScriptList>;
        Variant value;
 
        ScriptElementVariant takeVariant()
        {
            Q_ASSERT_X(std::holds_alternative<ScriptElementVariant>(value), "takeVariant",
                       "Should be a variant, did the parser change?");
            return std::get<ScriptElementVariant>(std::move(value));
        }
 
        bool isList() const { return std::holds_alternative<ScriptElements::ScriptList>(value); };
 
        ScriptElements::ScriptList takeList()
        {
            Q_ASSERT_X(std::holds_alternative<ScriptElements::ScriptList>(value), "takeList",
                       "Should be a List, did the parser change?");
            return std::get<ScriptElements::ScriptList>(std::move(value));
        }
 
        void setSemanticScope(const QQmlJSScope::ConstPtr &scope)
        {
            if (auto x = std::get_if<ScriptElementVariant>(&value)) {
                x->base()->setSemanticScope(scope);
                return;
            } else if (auto x = std::get_if<ScriptElements::ScriptList>(&value)) {
                x->setSemanticScope(scope);
                return;
            }
            Q_UNREACHABLE();
        }
    };
 
public:
    void enableScriptExpressions(bool enable = true) { m_enableScriptExpressions = enable; }
    void enableLoadFileLazily(bool enable = true) { m_loadFileLazily = enable; }
    std::shared_ptr<DomEnvironment> currentEnvironment()
    {
        return qmlFile.environment().ownerAs<DomEnvironment>();
    }
 
private:
 
    MutableDomItem qmlFile;
    std::shared_ptr<QmlFile> qmlFilePtr;
    QList<QmlStackElement> nodeStack;
    QList<ScriptStackElement> scriptNodeStack;
    QList<int> arrayBindingLevels;
    FileLocations::Tree rootMap;
    int m_nestedFunctionDepth = 0;
    bool m_enableScriptExpressions = false;
    bool m_loadFileLazily = false;
 
    // A Binding inside a UiPublicMember (= a Property definition) will shadow the
    // propertydefinition's binding identifiers with its own binding identifiers. Therefore, disable
    // bindingIdentifiers for the Binding inside a Property definition by using this flag.
    bool m_skipBindingIdentifiers = false;
 
    void setBindingIdentifiers(const Path &pathFromOwner, const AST::UiQualifiedId *identifiers,
                               Binding *bindingPtr);
    template<typename T>
    QmlStackElement &currentEl(int idx = 0)
    {
        Q_ASSERT_X(idx < nodeStack.size() && idx >= 0, "currentQmlObjectOrComponentEl",
                   "Stack does not contain enough elements!");
        int i = nodeStack.size() - idx;
        while (i-- > 0) {
            DomType k = nodeStack.at(i).item.kind;
            if (k == T::kindValue)
                return nodeStack[i];
        }
        Q_ASSERT_X(false, "currentEl", "Stack does not contan object of type ");
        return nodeStack.last();
    }
 
    template<typename T>
    ScriptStackElement &currentScriptEl(int idx = 0)
    {
        Q_ASSERT_X(m_enableScriptExpressions, "currentScriptEl",
                   "Cannot access script elements when they are disabled!");
 
        Q_ASSERT_X(idx < scriptNodeStack.size() && idx >= 0, "currentQmlObjectOrComponentEl",
                   "Stack does not contain enough elements!");
        int i = scriptNodeStack.size() - idx;
        while (i-- > 0) {
            DomType k = scriptNodeStack.at(i).kind;
            if (k == T::element_type::kindValue)
                return scriptNodeStack[i];
        }
        Q_ASSERT_X(false, "currentEl", "Stack does not contain object of type ");
        return scriptNodeStack.last();
    }
 
    template<typename T>
    T &current(int idx = 0)
    {
        return std::get<T>(currentEl<T>(idx).item.value);
    }
 
    index_type currentIndex() { return currentNodeEl().path.last().headIndex(); }
 
    QmlStackElement &currentQmlObjectOrComponentEl(int idx = 0);
 
    QmlStackElement &currentNodeEl(int i = 0);
    ScriptStackElement &currentScriptNodeEl(int i = 0);
 
    DomValue &currentNode(int i = 0);
 
    void removeCurrentNode(std::optional<DomType> expectedType);
    void removeCurrentScriptNode(std::optional<DomType> expectedType);
 
    void pushEl(const Path &p, const DomValue &it, AST::Node *n)
    {
        nodeStack.append({ p, it, createMap(it.kind, p, n) });
    }
 
    FileLocations::Tree createMap(const FileLocations::Tree &base, const Path &p, AST::Node *n);
 
    FileLocations::Tree createMap(DomType k, const Path &p, AST::Node *n);
 
    const ScriptElementVariant &
    finalizeScriptExpression(const ScriptElementVariant &element, const Path &pathFromOwner,
                             const FileLocations::Tree &ownerFileLocations);
 
    void setScriptExpression (const std::shared_ptr<ScriptExpression>& value);
 
    Path pathOfLastScriptNode() const;
 
    /*!
       \internal
       Helper to create string literals from AST nodes.
     */
    template<typename AstNodeT>
    static std::shared_ptr<ScriptElements::Literal> makeStringLiteral(QStringView value,
                                                                      AstNodeT *ast)
    {
        auto myExp = std::make_shared<ScriptElements::Literal>(ast->firstSourceLocation(),
                                                               ast->lastSourceLocation());
        myExp->setLiteralValue(value.toString());
        return myExp;
    }
 
    static std::shared_ptr<ScriptElements::Literal> makeStringLiteral(QStringView value,
                                                                      QQmlJS::SourceLocation loc)
    {
        auto myExp = std::make_shared<ScriptElements::Literal>(loc);
        myExp->setLiteralValue(value.toString());
        return myExp;
    }
 
    /*!
       \internal
       Helper to create script elements from AST nodes, as the DOM classes should be completely
       dependency-free from AST and parser classes. Using the AST classes in qqmldomastcreator is
       fine because it needs them for the construction/visit. \sa makeScriptList
     */
    template<typename ScriptElementT, typename AstNodeT,
             typename Enable =
                     std::enable_if_t<!std::is_same_v<ScriptElementT, ScriptElements::ScriptList>>>
    static decltype(auto) makeScriptElement(AstNodeT *ast)
    {
        auto myExp = std::make_shared<ScriptElementT>(ast->firstSourceLocation(),
                                                      ast->lastSourceLocation());
        return myExp;
    }
 
    /*!
       \internal
       Helper to create generic script elements from AST nodes.
       \sa makeScriptElement
     */
    template<typename AstNodeT>
    static std::shared_ptr<ScriptElements::GenericScriptElement>
    makeGenericScriptElement(AstNodeT *ast, DomType kind)
    {
        auto myExp = std::make_shared<ScriptElements::GenericScriptElement>(
                ast->firstSourceLocation(), ast->lastSourceLocation());
        myExp->setKind(kind);
        return myExp;
    }
 
    enum UnaryExpressionKind { Prefix, Postfix };
    std::shared_ptr<ScriptElements::GenericScriptElement>
    makeUnaryExpression(AST::Node *expression, QQmlJS::SourceLocation operatorToken,
                        bool hasExpression, UnaryExpressionKind type);
 
    static std::shared_ptr<ScriptElements::GenericScriptElement>
    makeGenericScriptElement(SourceLocation location, DomType kind)
    {
        auto myExp = std::make_shared<ScriptElements::GenericScriptElement>(location);
        myExp->setKind(kind);
        return myExp;
    }
 
    /*!
       \internal
       Helper to create script lists from AST nodes.
       \sa makeScriptElement
     */
    template<typename AstNodeT>
    static decltype(auto) makeScriptList(AstNodeT *ast)
    {
        auto myExp =
                ScriptElements::ScriptList(ast->firstSourceLocation(), ast->lastSourceLocation());
        return myExp;
    }
 
    template<typename ScriptElementT>
    void pushScriptElement(const ScriptElementT &element)
    {
        Q_ASSERT_X(m_enableScriptExpressions, "pushScriptElement",
                   "Cannot create script elements when they are disabled!");
        scriptNodeStack.append(ScriptStackElement::from(element));
    }
 
    void disableScriptElements()
    {
        m_enableScriptExpressions = false;
        scriptNodeStack.clear();
    }
 
    ScriptElementVariant scriptElementForQualifiedId(AST::UiQualifiedId *expression);
 
public:
    explicit QQmlDomAstCreatorBase(const MutableDomItem &qmlFile);
 
    bool visit(AST::UiProgram *program) override;
    void endVisit(AST::UiProgram *) override;
 
    bool visit(AST::UiPragma *el) override;
 
    bool visit(AST::UiImport *el) override;
 
    bool visit(AST::UiPublicMember *el) override;
    void endVisit(AST::UiPublicMember *el) override;
 
private:
    ScriptElementVariant prepareBodyForFunction(AST::FunctionExpression *fExpression);
 
public:
    bool visit(AST::FunctionExpression *el) override;
    void endVisit(AST::FunctionExpression *) override;
 
    bool visit(AST::FunctionDeclaration *el) override;
    void endVisit(AST::FunctionDeclaration *) override;
 
    bool visit(AST::UiSourceElement *el) override;
    void endVisit(AST::UiSourceElement *) override;
 
    void loadAnnotations(AST::UiObjectMember *el) { AST::Node::accept(el->annotations, this); }
 
    bool visit(AST::UiObjectDefinition *el) override;
    void endVisit(AST::UiObjectDefinition *) override;
 
    bool visit(AST::UiObjectBinding *el) override;
    void endVisit(AST::UiObjectBinding *) override;
 
    bool visit(AST::UiScriptBinding *el) override;
    void endVisit(AST::UiScriptBinding *) override;
 
    bool visit(AST::UiArrayBinding *el) override;
    void endVisit(AST::UiArrayBinding *) override;
 
    bool visit(AST::UiQualifiedId *) override;
 
    bool visit(AST::UiEnumDeclaration *el) override;
    void endVisit(AST::UiEnumDeclaration *) override;
 
    bool visit(AST::UiEnumMemberList *el) override;
    void endVisit(AST::UiEnumMemberList *el) override;
 
    bool visit(AST::UiInlineComponent *el) override;
    void endVisit(AST::UiInlineComponent *) override;
 
    bool visit(AST::UiRequired *el) override;
 
    bool visit(AST::UiAnnotation *el) override;
    void endVisit(AST::UiAnnotation *) override;
 
    // for Script elements:
    bool visit(AST::BinaryExpression *exp) override;
    void endVisit(AST::BinaryExpression *exp) override;
 
    bool visit(AST::Block *block) override;
    void endVisit(AST::Block *) override;
 
    bool visit(AST::YieldExpression *block) override;
    void endVisit(AST::YieldExpression *) override;
 
    bool visit(AST::ReturnStatement *block) override;
    void endVisit(AST::ReturnStatement *) override;
 
    bool visit(AST::ForStatement *forStatement) override;
    void endVisit(AST::ForStatement *forStatement) override;
 
    bool visit(AST::PatternElement *pe) override;
    void endVisit(AST::PatternElement *pe) override;
    void endVisitHelper(AST::PatternElement *pe,
                        const std::shared_ptr<ScriptElements::GenericScriptElement> &element);
 
    bool visit(AST::IfStatement *) override;
    void endVisit(AST::IfStatement *) override;
 
    bool visit(AST::FieldMemberExpression *) override;
    void endVisit(AST::FieldMemberExpression *) override;
 
    bool visit(AST::ArrayMemberExpression *) override;
    void endVisit(AST::ArrayMemberExpression *) override;
 
    bool visit(AST::CallExpression *) override;
    void endVisit(AST::CallExpression *) override;
 
    bool visit(AST::ArrayPattern *) override;
    void endVisit(AST::ArrayPattern *) override;
 
    bool visit(AST::ObjectPattern *) override;
    void endVisit(AST::ObjectPattern *) override;
 
    bool visit(AST::PatternProperty *) override;
    void endVisit(AST::PatternProperty *) override;
 
    bool visit(AST::VariableStatement *) override;
    void endVisit(AST::VariableStatement *) override;
 
    bool visit(AST::Type *expression) override;
    void endVisit(AST::Type *expression) override;
 
    bool visit(AST::DefaultClause *) override;
    void endVisit(AST::DefaultClause *) override;
 
    bool visit(AST::CaseClause *) override;
    void endVisit(AST::CaseClause *) override;
 
    bool visit(AST::CaseClauses *) override;
    void endVisit(AST::CaseClauses *) override;
 
    bool visit(AST::CaseBlock *) override;
    void endVisit(AST::CaseBlock *) override;
 
    bool visit(AST::SwitchStatement *) override;
    void endVisit(AST::SwitchStatement *) override;
 
    bool visit(AST::WhileStatement *) override;
    void endVisit(AST::WhileStatement *) override;
 
    bool visit(AST::DoWhileStatement *) override;
    void endVisit(AST::DoWhileStatement *) override;
 
    bool visit(AST::ForEachStatement *) override;
    void endVisit(AST::ForEachStatement *) override;
 
    bool visit(AST::ClassExpression *) override;
    void endVisit(AST::ClassExpression *) override;
 
    bool visit(AST::TryStatement *) override;
    void endVisit(AST::TryStatement *) override;
 
    bool visit(AST::Catch *) override;
    void endVisit(AST::Catch *) override;
 
    bool visit(AST::Finally *) override;
    void endVisit(AST::Finally *) override;
 
    bool visit(AST::ThrowStatement *) override;
    void endVisit(AST::ThrowStatement *) override;
 
    bool visit(AST::LabelledStatement *) override;
    void endVisit(AST::LabelledStatement *) override;
 
    bool visit(AST::ContinueStatement *) override;
    void endVisit(AST::ContinueStatement *) override;
 
    bool visit(AST::BreakStatement *) override;
    void endVisit(AST::BreakStatement *) override;
 
    bool visit(AST::CommaExpression *) override;
    void endVisit(AST::CommaExpression *) override;
 
    bool visit(AST::ConditionalExpression *) override;
    void endVisit(AST::ConditionalExpression *) override;
 
    bool visit(AST::UnaryMinusExpression *) override;
    void endVisit(AST::UnaryMinusExpression *) override;
 
    bool visit(AST::UnaryPlusExpression *) override;
    void endVisit(AST::UnaryPlusExpression *) override;
 
    bool visit(AST::TildeExpression *) override;
    void endVisit(AST::TildeExpression *) override;
 
    bool visit(AST::NotExpression *) override;
    void endVisit(AST::NotExpression *) override;
 
    bool visit(AST::TypeOfExpression *) override;
    void endVisit(AST::TypeOfExpression *) override;
 
    bool visit(AST::DeleteExpression *) override;
    void endVisit(AST::DeleteExpression *) override;
 
    bool visit(AST::VoidExpression *) override;
    void endVisit(AST::VoidExpression *) override;
 
    bool visit(AST::PostDecrementExpression *) override;
    void endVisit(AST::PostDecrementExpression *) override;
 
    bool visit(AST::PostIncrementExpression *) override;
    void endVisit(AST::PostIncrementExpression *) override;
 
    bool visit(AST::PreDecrementExpression *) override;
    void endVisit(AST::PreDecrementExpression *) override;
 
    bool visit(AST::PreIncrementExpression *) override;
    void endVisit(AST::PreIncrementExpression *) override;
 
    bool visit(AST::EmptyStatement *) override;
    void endVisit(AST::EmptyStatement *) override;
 
    bool visit(AST::NestedExpression *) override;
    void endVisit(AST::NestedExpression *) override;
 
    bool visit(AST::NewExpression *) override;
    void endVisit(AST::NewExpression *) override;
 
    bool visit(AST::NewMemberExpression *) override;
    void endVisit(AST::NewMemberExpression *) override;
 
    void endVisit(AST::WithStatement *) override;
 
    // lists of stuff whose children don't need a qqmljsscope: visitation order can be custom
    bool visit(AST::UiParameterList *) override;
    bool visit(AST::Elision *elision) override;
 
 
    // lists of stuff whose children need a qqmljsscope: visitation order cannot be custom
    void endVisit(AST::StatementList *list) override;
    void endVisit(AST::VariableDeclarationList *vdl) override;
    void endVisit(AST::ArgumentList *) override;
    void endVisit(AST::PatternElementList *) override;
    void endVisit(AST::PatternPropertyList *) override;
    void endVisit(AST::FormalParameterList *el) override;
    void endVisit(AST::TemplateLiteral *) override;
    void endVisit(AST::TaggedTemplate *) override;
 
 
    // literals and ids
    bool visit(AST::IdentifierExpression *expression) override;
    bool visit(AST::NumericLiteral *expression) override;
    bool visit(AST::StringLiteral *expression) override;
    bool visit(AST::NullExpression *expression) override;
    bool visit(AST::TrueLiteral *expression) override;
    bool visit(AST::FalseLiteral *expression) override;
    bool visit(AST::ComputedPropertyName *expression) override;
    bool visit(AST::IdentifierPropertyName *expression) override;
    bool visit(AST::NumericLiteralPropertyName *expression) override;
    bool visit(AST::StringLiteralPropertyName *expression) override;
    bool visit(AST::TypeAnnotation *expression) override;
    bool visit(AST::RegExpLiteral *) override;
    bool visit(AST::ThisExpression *) override;
    bool visit(AST::SuperLiteral *) override;
 
    void throwRecursionDepthError() override;
 
    bool stackHasScriptVariant() const
    {
        return !scriptNodeStack.isEmpty() && !scriptNodeStack.last().isList();
    }
    bool stackHasScriptList() const
    {
        return !scriptNodeStack.isEmpty() && scriptNodeStack.last().isList();
    }
 
private:
    template<typename T>
    void endVisitForLists(T *list, const std::function<int(T *)> &scriptElementsPerEntry = {});
 
public:
    friend class QQmlDomAstCreatorWithQQmlJSScope;
};
 
template<typename U, typename... V>
using IsInList = std::disjunction<std::is_same<U, V>...>;
template<typename U>
using RequiresCustomIteration =
        IsInList<U, AST::PatternElementList, AST::PatternPropertyList, AST::FormalParameterList,
                 AST::VariableDeclarationList, AST::TemplateLiteral>;
 
template <typename T, typename std::enable_if_t<RequiresCustomIteration<T>::value, bool> = true>
bool visitWithCustomListIteration(T *t, AST::Visitor *visitor)
{
    for (T *it = t; it; it = it->next) {
        if constexpr (std::is_same_v<T, AST::PatternElementList>) {
            AST::Node::accept(it->elision, visitor);
            AST::Node::accept(it->element, visitor);
        } else if constexpr (std::is_same_v<T, AST::PatternPropertyList>) {
            AST::Node::accept(it->property, visitor);
        } else if constexpr (std::is_same_v<T, AST::FormalParameterList>) {
            AST::Node::accept(it->element, visitor);
        } else if constexpr (std::is_same_v<T, AST::VariableDeclarationList>) {
            AST::Node::accept(it->declaration, visitor);
        } else if constexpr (std::is_same_v<T, AST::ArgumentList>) {
            AST::Node::accept(it->expression, visitor);
        } else if constexpr (std::is_same_v<T, AST::PatternElementList>) {
            AST::Node::accept(it->elision, visitor);
            AST::Node::accept(it->element, visitor);
        } else if constexpr (std::is_same_v<T, AST::TemplateLiteral>) {
            AST::Node::accept(it->expression, visitor);
        } else {
            Q_UNREACHABLE();
        }
    }
    return false;
}
 
template <typename T, typename std::enable_if_t<!RequiresCustomIteration<T>::value, bool> = true>
bool visitWithCustomListIteration(T *, AST::Visitor *)
{
    return true;
}
 
class QQmlDomAstCreator final : public QQmlDomAstCreatorBase
{
    using QQmlDomAstCreatorBase::QQmlDomAstCreatorBase;
    using QQmlDomAstCreatorBase::visit;
    using QQmlDomAstCreatorBase::endVisit;
 
#define X(name) bool visit(AST::name *) override;
    QQmlJSASTClassListToVisit
#undef X
};
 
class QQmlDomAstCreatorWithQQmlJSScope : public AST::Visitor
{
public:
    QQmlDomAstCreatorWithQQmlJSScope(MutableDomItem &qmlFile, QQmlJSLogger *logger,
                                     QQmlJSImporter *importer);
 
#define X(name)
    bool visit(AST::name *) override;
    void endVisit(AST::name *) override;
    QQmlJSASTClassListToVisit
#undef X
 
    virtual void throwRecursionDepthError() override;
    /*!
       \internal
       Disable the DOM for scriptexpressions, as not yet unimplemented script elements might crash
       the construction.
     */
    void enableScriptExpressions(bool enable = true)
    {
        m_enableScriptExpressions = enable;
        m_domCreator.enableScriptExpressions(enable);
    }
 
    void enableLoadFileLazily(bool enable = true)
    {
        m_loadFileLazily = enable;
        m_domCreator.enableLoadFileLazily(enable);
    }
 
    QQmlJSImportVisitor &scopeCreator() { return m_scopeCreator; }
 
private:
    void setScopeInDomAfterEndvisit();
    void setScopeInDomBeforeEndvisit();
 
    enum VisitorKind : bool { DomCreator, ScopeCreator };
    /*! \internal
        \brief Holds the information to reactivate a visitor
        This struct tracks a visitor during its inactive phases
        and holds the information needed to reactivate the visitor.
    */
    struct InactiveVisitorMarker
    {
        qsizetype count;
        AST::Node::Kind nodeKind;
        VisitorKind inactiveVisitorKind;
 
        VisitorKind stillActiveVisitorKind() const
        {
            return inactiveVisitorKind == DomCreator ? ScopeCreator : DomCreator;
        }
    };
 
    static void initMarkerForActiveVisitor(std::optional<InactiveVisitorMarker> &inactiveVisitorMarker,
                               AST::Node::Kind nodeKind, bool continueForDom)
    {
        inactiveVisitorMarker.emplace();
        inactiveVisitorMarker->inactiveVisitorKind = continueForDom ? ScopeCreator : DomCreator;
        inactiveVisitorMarker->count = 1;
        inactiveVisitorMarker->nodeKind = nodeKind;
    };
 
    template<typename T>
    bool visitT(T *t)
    {
        const auto handleVisitResult = [this, t](const bool continueVisit) {
            if (m_inactiveVisitorMarker && m_inactiveVisitorMarker->nodeKind == t->kind)
                m_inactiveVisitorMarker->count += 1;
 
            if (continueVisit)
                return visitWithCustomListIteration(t, this);
            return continueVisit;
        };
 
        // first case: no marker, both can visit
        if (!m_inactiveVisitorMarker) {
            bool continueForDom = m_domCreator.visit(t);
            bool continueForScope = m_scopeCreator.visit(t);
            if (!continueForDom && !continueForScope)
                return false;
            else if (continueForDom ^ continueForScope) {
                initMarkerForActiveVisitor(m_inactiveVisitorMarker, AST::Node::Kind(t->kind),
                                           continueForDom);
                return visitWithCustomListIteration(t, this);
            } else {
                Q_ASSERT(continueForDom && continueForScope);
                return visitWithCustomListIteration(t, this);
            }
            Q_UNREACHABLE();
        }
 
        // second case: a marker, just one visit
        switch (m_inactiveVisitorMarker->stillActiveVisitorKind()) {
        case DomCreator:
            return handleVisitResult(m_domCreator.visit(t));
        case ScopeCreator:
            return handleVisitResult(m_scopeCreator.visit(t));
        };
        Q_UNREACHABLE();
    }
 
    void loadQmlDependenciesInDom();
 
    template<typename T>
    void endVisitT(T *t)
    {
        if constexpr (std::is_same_v<T, AST::UiHeaderItemList>) {
            const bool allImportsVisited = !static_cast<AST::UiHeaderItemList *>(t)->next;
            if (allImportsVisited)
                loadQmlDependenciesInDom();
        }
        if (m_inactiveVisitorMarker && m_inactiveVisitorMarker->nodeKind == t->kind) {
            m_inactiveVisitorMarker->count -= 1;
            if (m_inactiveVisitorMarker->count == 0)
                m_inactiveVisitorMarker.reset();
        }
        if (m_inactiveVisitorMarker) {
            switch (m_inactiveVisitorMarker->stillActiveVisitorKind()) {
            case DomCreator:
                m_domCreator.endVisit(t);
                return;
            case ScopeCreator:
                m_scopeCreator.endVisit(t);
                return;
            };
            Q_UNREACHABLE();
        }
 
        setScopeInDomBeforeEndvisit();
        m_domCreator.endVisit(t);
        setScopeInDomAfterEndvisit();
        m_scopeCreator.endVisit(t);
    }
 
    QQmlJSLogger *m_logger = nullptr;
    QQmlJSImporter *m_importer = nullptr;
    QString m_implicitImportDirectory;
    QQmlJSImportVisitor m_scopeCreator;
    QQmlDomAstCreatorBase m_domCreator;
 
    std::optional<InactiveVisitorMarker> m_inactiveVisitorMarker;
    bool m_enableScriptExpressions = false;
    bool m_loadFileLazily = false;
};
 
} // end namespace Dom
} // end namespace QQmlJS
 
QT_END_NAMESPACE
#endif // QQMLDOMASTCREATOR_P_H