qqmlsa.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
#include "qqmlsa.h"
#include "qqmlsa_p.h"
#include "qqmlsasourcelocation.h"
 
#include "qqmljsscope_p.h"
#include "qqmljslogger_p.h"
#include "qqmljstyperesolver_p.h"
#include "qqmljsimportvisitor_p.h"
#include "qqmljsutils_p.h"
#include "qdeferredpointer_p.h"
 
#include <QtQmlCompiler/private/qqmlsasourcelocation_p.h>
 
#include <memory>
#include <new>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
namespace QQmlSA {
 
static_assert(QQmlJSScope::sizeofQQmlSAElement() == sizeof(Element));
 
Binding::Bindings::Bindings() : d_ptr{ new BindingsPrivate{ this } } { }
 
BindingsPrivate::BindingsPrivate(QQmlSA::Binding::Bindings *interface) : q_ptr{ interface } { }
 
Binding::Bindings::Bindings(const Bindings &other)
    : d_ptr{ new BindingsPrivate{ this, *other.d_func() } }
{
}
 
Binding::Bindings::~Bindings() = default;
 
BindingsPrivate::BindingsPrivate(QQmlSA::Binding::Bindings *interface, const BindingsPrivate &other)
    : m_bindings{ other.m_bindings.begin(), other.m_bindings.end() }, q_ptr{ interface }
{
}
 
BindingsPrivate::BindingsPrivate(QQmlSA::Binding::Bindings *interface, BindingsPrivate &&other)
    : m_bindings{ std::move(other.m_bindings) }, q_ptr{ interface }
{
}
 
QMultiHash<QString, Binding>::const_iterator Binding::Bindings::constBegin() const
{
    Q_D(const Bindings);
    return d->constBegin();
}
 
QMultiHash<QString, Binding>::const_iterator BindingsPrivate::constBegin() const
{
    return m_bindings.constBegin();
}
 
QMultiHash<QString, Binding>::const_iterator Binding::Bindings::constEnd() const
{
    Q_D(const Bindings);
    return d->constEnd();
}
 
QMultiHash<QString, Binding>::const_iterator BindingsPrivate::constEnd() const
{
    return m_bindings.constEnd();
}
 
Binding::Binding() : d_ptr{ new BindingPrivate{ this } } { }
 
BindingPrivate::BindingPrivate(Binding *interface) : q_ptr{ interface } { }
 
Binding::Binding(const Binding &other) : d_ptr{ new BindingPrivate{ this, *other.d_func() } } { }
 
Binding::Binding(Binding &&other) noexcept
    : d_ptr{ new BindingPrivate{ this, *other.d_func() } } { }
 
Binding &Binding::operator=(const Binding &other)
{
    if (*this == other)
        return *this;
 
    d_func()->m_binding = other.d_func()->m_binding;
    d_func()->q_ptr = this;
    return *this;
}
 
Binding &Binding::operator=(Binding &&other) noexcept
{
    if (*this == other)
        return *this;
 
    d_func()->m_binding = std::move(other.d_func()->m_binding);
    d_func()->q_ptr = this;
    return *this;
}
 
Binding::~Binding() = default;
 
bool Binding::operatorEqualsImpl(const Binding &lhs, const Binding &rhs)
{
    return lhs.d_func()->m_binding == rhs.d_func()->m_binding;
}
 
BindingPrivate::BindingPrivate(Binding *interface, const BindingPrivate &other)
    : m_binding{ other.m_binding }, q_ptr{ interface }
{
}
 
QQmlSA::Binding BindingPrivate::createBinding(const QQmlJSMetaPropertyBinding &binding)
{
    QQmlSA::Binding saBinding;
    saBinding.d_func()->m_binding = binding;
    return saBinding;
}
 
QQmlJSMetaPropertyBinding BindingPrivate::binding(QQmlSA::Binding &binding)
{
    return binding.d_func()->m_binding;
}
 
const QQmlJSMetaPropertyBinding BindingPrivate::binding(const QQmlSA::Binding &binding)
{
    return binding.d_func()->m_binding;
}
 
Element Binding::groupType() const
{
    return QQmlJSScope::createQQmlSAElement(BindingPrivate::binding(*this).groupType());
}
 
QQmlSA::BindingType Binding::bindingType() const
{
    return BindingPrivate::binding(*this).bindingType();
}
 
QString Binding::stringValue() const
{
    return BindingPrivate::binding(*this).stringValue();
}
 
QString Binding::propertyName() const
{
    return BindingPrivate::binding(*this).propertyName();
}
 
Element Binding::attachingType() const
{
    return QQmlJSScope::createQQmlSAElement(BindingPrivate::binding(*this).attachingType());
}
 
QQmlSA::SourceLocation Binding::sourceLocation() const
{
    return QQmlSA::SourceLocationPrivate::createQQmlSASourceLocation(
            BindingPrivate::binding(*this).sourceLocation());
}
 
double Binding::numberValue() const
{
    return BindingPrivate::binding(*this).numberValue();
}
 
QQmlSA::ScriptBindingKind Binding::scriptKind() const
{
    return BindingPrivate::binding(*this).scriptKind();
}
 
bool Binding::hasObject() const
{
    return BindingPrivate::binding(*this).hasObject();
}
 
QQmlSA::Element Binding::objectType() const
{
    return QQmlJSScope::createQQmlSAElement(BindingPrivate::binding(*this).objectType());
}
 
bool Binding::hasUndefinedScriptValue() const
{
    const auto &jsBinding = BindingPrivate::binding(*this);
    return jsBinding.bindingType() == BindingType::Script
            && jsBinding.scriptValueType() == ScriptValue_Undefined;
}
 
bool QQmlSA::Binding::isLiteralBinding(QQmlSA::BindingType bindingType)
{
    return QQmlJSMetaPropertyBinding::isLiteralBinding(bindingType);
}
 
QQmlSA::Method::Methods::Methods() : d_ptr{ new MethodsPrivate{ this } } { }
 
QQmlSA::Method::Methods::Methods(const Methods &other)
    : d_ptr{ new MethodsPrivate{ this, *other.d_func() } }
{
}
 
QQmlSA::Method::Methods::~Methods() = default;
 
QMultiHash<QString, Method>::const_iterator Method::Methods::constBegin() const
{
    Q_D(const Methods);
    return d->constBegin();
}
 
QMultiHash<QString, Method>::const_iterator MethodsPrivate::constBegin() const
{
    return m_methods.constBegin();
}
 
QMultiHash<QString, Method>::const_iterator Method::Methods::constEnd() const
{
    Q_D(const Methods);
    return d->constEnd();
}
QMultiHash<QString, Method>::const_iterator MethodsPrivate::constEnd() const
{
    return m_methods.constEnd();
}
 
MethodsPrivate::MethodsPrivate(QQmlSA::Method::Methods *interface) : q_ptr{ interface } { }
 
MethodsPrivate::MethodsPrivate(QQmlSA::Method::Methods *interface, const MethodsPrivate &other)
    : m_methods{ other.m_methods }, q_ptr{ interface }
{
}
 
MethodsPrivate::MethodsPrivate(QQmlSA::Method::Methods *interface, MethodsPrivate &&other)
    : m_methods{ std::move(other.m_methods) }, q_ptr{ interface }
{
}
 
MethodPrivate::MethodPrivate(Method *interface) : q_ptr{ interface } { }
 
MethodPrivate::MethodPrivate(Method *interface, const MethodPrivate &other)
    : m_method{ other.m_method }, q_ptr{ interface }
{
}
 
QString MethodPrivate::methodName() const
{
    return m_method.methodName();
}
 
QQmlSA::SourceLocation MethodPrivate::sourceLocation() const
{
    return QQmlSA::SourceLocationPrivate::createQQmlSASourceLocation(m_method.sourceLocation());
}
 
MethodType MethodPrivate::methodType() const
{
    return m_method.methodType();
}
 
Method::Method() : d_ptr{ new MethodPrivate{ this } } { }
 
Method::Method(const Method &other) : d_ptr{ new MethodPrivate{ this, *other.d_func() } } { }
 
Method::Method(Method &&other) noexcept
    : d_ptr{ new MethodPrivate{ this, std::move(*other.d_func()) } }
{
}
 
Method &Method::operator=(const Method &other)
{
    if (*this == other)
        return *this;
 
    d_func()->m_method = other.d_func()->m_method;
    d_func()->q_ptr = this;
    return *this;
}
 
Method &Method::operator=(Method &&other) noexcept
{
    if (*this == other)
        return *this;
 
    d_func()->m_method = std::move(other.d_func()->m_method);
    d_func()->q_ptr = this;
    return *this;
}
 
Method::~Method() = default;
 
QString Method::methodName() const
{
    Q_D(const Method);
    return d->methodName();
}
 
MethodType Method::methodType() const
{
    Q_D(const Method);
    return d->methodType();
}
 
QQmlSA::SourceLocation Method::sourceLocation() const
{
    Q_D(const Method);
    return d->sourceLocation();
}
 
bool Method::operatorEqualsImpl(const Method &lhs, const Method &rhs)
{
    return lhs.d_func()->m_method == rhs.d_func()->m_method;
}
 
QQmlSA::Method MethodPrivate::createMethod(const QQmlJSMetaMethod &jsMethod)
{
    QQmlSA::Method saMethod;
    auto &wrappedMethod = saMethod.d_func()->m_method;
    wrappedMethod = jsMethod;
    return saMethod;
}
 
QQmlSA::Method::Methods
MethodsPrivate::createMethods(const QMultiHash<QString, QQmlJSMetaMethod> &hash)
{
    QMultiHash<QString, QQmlSA::Method> saMethods;
    for (const auto &[key, value] : hash.asKeyValueRange()) {
        saMethods.insert(key, MethodPrivate::createMethod(value));
    }
 
    QQmlSA::Method::Methods methods;
    methods.d_func()->m_methods = std::move(saMethods);
    return methods;
}
 
QQmlJSMetaMethod MethodPrivate::method(const QQmlSA::Method &method)
{
    return method.d_func()->m_method;
}
 
PropertyPrivate::PropertyPrivate(Property *interface) : q_ptr{ interface } { }
 
PropertyPrivate::PropertyPrivate(Property *interface, const PropertyPrivate &other)
    : m_property{ other.m_property }, q_ptr{ interface }
{
}
 
PropertyPrivate::PropertyPrivate(Property *interface, PropertyPrivate &&other)
    : m_property{ std::move(other.m_property) }, q_ptr{ interface }
{
}
 
QString PropertyPrivate::typeName() const
{
    return m_property.typeName();
}
 
bool PropertyPrivate::isValid() const
{
    return m_property.isValid();
}
 
bool PropertyPrivate::isReadonly() const
{
    return !m_property.isWritable();
}
 
QQmlSA::Element PropertyPrivate::type() const
{
    return QQmlJSScope::createQQmlSAElement(m_property.type());
}
 
QQmlJSMetaProperty PropertyPrivate::property(const QQmlSA::Property &property)
{
    return property.d_func()->m_property;
}
 
QQmlSA::Property PropertyPrivate::createProperty(const QQmlJSMetaProperty &property)
{
    QQmlSA::Property saProperty;
    auto &wrappedProperty = saProperty.d_func()->m_property;
    wrappedProperty = property;
    return saProperty;
}
 
Property::Property() : d_ptr{ new PropertyPrivate{ this } } { }
 
Property::Property(const Property &other)
    : d_ptr{ new PropertyPrivate{ this, *other.d_func() } } { }
 
Property::Property(Property &&other) noexcept
    : d_ptr{ new PropertyPrivate{ this, std::move(*other.d_func()) } }
{
}
 
Property &Property::operator=(const Property &other)
{
    if (*this == other)
        return *this;
 
    d_func()->m_property = other.d_func()->m_property;
    d_func()->q_ptr = this;
    return *this;
}
 
Property &Property::operator=(Property &&other) noexcept
{
    if (*this == other)
        return *this;
 
    d_func()->m_property = std::move(other.d_func()->m_property);
    d_func()->q_ptr = this;
    return *this;
}
 
Property::~Property() = default;
 
QString Property::typeName() const
{
    Q_D(const Property);
    return d->typeName();
}
 
bool Property::isValid() const
{
    Q_D(const Property);
    return d->isValid();
}
 
bool Property::isReadonly() const
{
    Q_D(const Property);
    return d->isReadonly();
}
 
QQmlSA::Element Property::type() const
{
    Q_D(const Property);
    return d->type();
}
 
 
bool Property::operatorEqualsImpl(const Property &lhs, const Property &rhs)
{
    return lhs.d_func()->m_property == rhs.d_func()->m_property;
}
 
Element::Element()
{
    new (m_data) QQmlJSScope::ConstPtr();
}
 
Element::Element(const Element &other)
{
    new (m_data) QQmlJSScope::ConstPtr(QQmlJSScope::scope(other));
}
 
Element &Element::operator=(const Element &other)
{
    if (this == &other)
        return *this;
 
    *reinterpret_cast<QQmlJSScope::ConstPtr *>(m_data) = QQmlJSScope::scope(other);
    return *this;
}
 
Element::~Element()
{
    (*reinterpret_cast<QQmlJSScope::ConstPtr *>(m_data)).QQmlJSScope::ConstPtr::~ConstPtr();
}
 
QQmlJSScope::ScopeType Element::scopeType() const
{
    return QQmlJSScope::scope(*this)->scopeType();
}
 
Element Element::baseType() const
{
    return QQmlJSScope::createQQmlSAElement(QQmlJSScope::scope(*this)->baseType());
}
 
QString Element::baseTypeName() const
{
    return QQmlJSScope::prettyName(QQmlJSScope::scope(*this)->baseTypeName());
}
 
Element Element::parentScope() const
{
    return QQmlJSScope::createQQmlSAElement(QQmlJSScope::scope(*this)->parentScope());
}
 
bool Element::inherits(const Element &element) const
{
    return QQmlJSScope::scope(*this)->inherits(QQmlJSScope::scope(element));
}
 
bool Element::isNull() const
{
    return QQmlJSScope::scope(*this).isNull();
}
 
QString Element::internalId() const
{
    return QQmlJSScope::scope(*this)->internalName();
}
 
AccessSemantics Element::accessSemantics() const
{
    return QQmlJSScope::scope(*this)->accessSemantics();
}
 
bool QQmlSA::Element::isComposite() const
{
    return QQmlJSScope::scope(*this)->isComposite();
}
 
bool Element::hasProperty(const QString &propertyName) const
{
    return QQmlJSScope::scope(*this)->hasProperty(propertyName);
}
 
bool Element::hasOwnProperty(const QString &propertyName) const
{
    return QQmlJSScope::scope(*this)->hasOwnProperty(propertyName);
}
 
QQmlSA::Property Element::property(const QString &propertyName) const
{
    return PropertyPrivate::createProperty(QQmlJSScope::scope(*this)->property(propertyName));
}
 
bool Element::isPropertyRequired(const QString &propertyName) const
{
    return QQmlJSScope::scope(*this)->isPropertyRequired(propertyName);
}
 
QString Element::defaultPropertyName() const
{
    return QQmlJSScope::scope(*this)->defaultPropertyName();
}
 
bool Element::hasMethod(const QString &methodName) const
{
    return QQmlJSScope::scope(*this)->hasMethod(methodName);
}
 
Method::Methods Element::ownMethods() const
{
    return MethodsPrivate::createMethods(QQmlJSScope::scope(*this)->ownMethods());
}
 
QQmlSA::SourceLocation Element::sourceLocation() const
{
    return QQmlSA::SourceLocationPrivate::createQQmlSASourceLocation(
            QQmlJSScope::scope(*this)->sourceLocation());
}
 
QString Element::filePath() const
{
    return QQmlJSScope::scope(*this)->filePath();
}
 
bool Element::hasPropertyBindings(const QString &name) const
{
    return QQmlJSScope::scope(*this)->hasPropertyBindings(name);
}
 
bool Element::hasOwnPropertyBindings(const QString &propertyName) const
{
    return QQmlJSScope::scope(*this)->hasOwnPropertyBindings(propertyName);
}
 
Binding::Bindings Element::ownPropertyBindings() const
{
    return BindingsPrivate::createBindings(QQmlJSScope::scope(*this)->ownPropertyBindings());
}
 
Binding::Bindings Element::ownPropertyBindings(const QString &propertyName) const
{
    return BindingsPrivate::createBindings(
            QQmlJSScope::scope(*this)->ownPropertyBindings(propertyName));
}
 
QList<Binding> Element::propertyBindings(const QString &propertyName) const
{
    const auto &bindings = QQmlJSScope::scope(*this)->propertyBindings(propertyName);
 
    QList<Binding> saBindings;
    for (const auto &jsBinding : bindings) {
        saBindings.push_back(BindingPrivate::createBinding(jsBinding));
    }
    return saBindings;
}
 
QQmlSA::Binding::Bindings
BindingsPrivate::createBindings(const QMultiHash<QString, QQmlJSMetaPropertyBinding> &hash)
{
    QMultiHash<QString, QQmlSA::Binding> saBindings;
    for (const auto &[key, value] : hash.asKeyValueRange()) {
        saBindings.insert(key, BindingPrivate::createBinding(value));
    }
 
    QQmlSA::Binding::Bindings bindings;
    bindings.d_func()->m_bindings = std::move(saBindings);
    return bindings;
}
 
QQmlSA::Binding::Bindings BindingsPrivate::createBindings(
        QPair<QMultiHash<QString, QQmlJSMetaPropertyBinding>::const_iterator,
              QMultiHash<QString, QQmlJSMetaPropertyBinding>::const_iterator> iterators)
{
    QMultiHash<QString, QQmlSA::Binding> saBindings;
    for (auto it = iterators.first; it != iterators.second; ++it) {
        saBindings.insert(it.key(), BindingPrivate::createBinding(it.value()));
    }
 
    QQmlSA::Binding::Bindings bindings;
    bindings.d_func()->m_bindings = std::move(saBindings);
    return bindings;
}
 
Element::operator bool() const
{
    return bool(QQmlJSScope::scope(*this));
}
 
bool Element::operator!() const
{
    return !QQmlJSScope::scope(*this);
}
 
QString Element::name() const
{
    if (isNull())
        return {};
    return QQmlJSScope::prettyName(QQmlJSScope::scope(*this)->internalName());
}
 
bool Element::operatorEqualsImpl(const Element &lhs, const Element &rhs)
{
    return QQmlJSScope::scope(lhs) == QQmlJSScope::scope(rhs);
}
 
qsizetype Element::qHashImpl(const Element &key, qsizetype seed) noexcept
{
    return qHash(QQmlJSScope::scope(key), seed);
}
 
class GenericPassPrivate {
    Q_DECLARE_PUBLIC(GenericPass);
 
public:
    GenericPassPrivate(GenericPass *interface, PassManager *manager)
        : m_manager{ manager }, q_ptr{ interface }
    {
        Q_ASSERT(manager);
    }
 
private:
    PassManager *m_manager;
 
    GenericPass *q_ptr;
};
 
GenericPass::~GenericPass() = default;
 
GenericPass::GenericPass(PassManager *manager)
    : d_ptr{ new GenericPassPrivate{ this, manager } } { }
 
void GenericPass::emitWarning(QAnyStringView diagnostic, LoggerWarningId id)
{
    emitWarning(diagnostic, id, QQmlSA::SourceLocation{});
}
 
void GenericPass::emitWarning(QAnyStringView diagnostic, LoggerWarningId id,
                              QQmlSA::SourceLocation srcLocation)
{
    Q_D(const GenericPass);
    PassManagerPrivate::visitor(*d->m_manager)
            ->logger()
            ->log(diagnostic.toString(), id,
                  QQmlSA::SourceLocationPrivate::sourceLocation(srcLocation));
}
 
void GenericPass::emitWarning(QAnyStringView diagnostic, LoggerWarningId id,
                              QQmlSA::SourceLocation srcLocation, const QQmlSA::FixSuggestion &fix)
{
    Q_D(const GenericPass);
    PassManagerPrivate::visitor(*d->m_manager)
            ->logger()
            ->log(diagnostic.toString(), id,
                  QQmlSA::SourceLocationPrivate::sourceLocation(srcLocation), true, true,
                  FixSuggestionPrivate::fixSuggestion(fix));
}
 
Element GenericPass::resolveTypeInFileScope(QAnyStringView typeName)
{
    Q_D(const GenericPass);
    const auto scope =
            PassManagerPrivate::visitor(*d->m_manager)->imports().type(typeName.toString()).scope;
    return QQmlJSScope::createQQmlSAElement(scope);
}
 
Element GenericPass::resolveAttachedInFileScope(QAnyStringView typeName)
{
    const auto type = resolveTypeInFileScope(typeName);
    const auto scope = QQmlJSScope::scope(type);
 
    if (scope.isNull())
        return QQmlJSScope::createQQmlSAElement(QQmlJSScope::ConstPtr(nullptr));
 
    return QQmlJSScope::createQQmlSAElement(scope->attachedType());
}
 
Element GenericPass::resolveType(QAnyStringView moduleName, QAnyStringView typeName)
{
    Q_D(const GenericPass);
    QQmlJSImporter *typeImporter = PassManagerPrivate::visitor(*d->m_manager)->importer();
    const auto module = typeImporter->importModule(moduleName.toString());
    const auto scope = module.type(typeName.toString()).scope;
    return QQmlJSScope::createQQmlSAElement(scope);
}
 
Element GenericPass::resolveBuiltinType(QAnyStringView typeName) const
{
    Q_D(const GenericPass);
    QQmlJSImporter *typeImporter = PassManagerPrivate::visitor(*d->m_manager)->importer();
    auto typeNameString = typeName.toString();
    // we have to check both cpp names
    auto scope = typeImporter->builtinInternalNames().type(typeNameString).scope;
    if (!scope) {
        // and qml names (e.g. for bool) - builtinImportHelper is private, so we can't do it in one call
        auto builtins = typeImporter->importBuiltins();
        scope = builtins.type(typeNameString).scope;
    }
    return QQmlJSScope::createQQmlSAElement(scope);
}
 
Element GenericPass::resolveAttached(QAnyStringView moduleName, QAnyStringView typeName)
{
    const auto &resolvedType = resolveType(moduleName, typeName);
    return QQmlJSScope::createQQmlSAElement(QQmlJSScope::scope(resolvedType)->attachedType());
}
 
Element GenericPass::resolveLiteralType(const QQmlSA::Binding &binding)
{
    Q_D(const GenericPass);
 
    return QQmlJSScope::createQQmlSAElement(BindingPrivate::binding(binding).literalType(
            PassManagerPrivate::resolver(*d->m_manager)));
}
 
Element GenericPass::resolveIdToElement(QAnyStringView id, const Element &context)
{
    Q_D(const GenericPass);
    const auto scope = PassManagerPrivate::visitor(*d->m_manager)
                               ->addressableScopes()
                               .scope(id.toString(), QQmlJSScope::scope(context));
    return QQmlJSScope::createQQmlSAElement(scope);
}
 
QString GenericPass::resolveElementToId(const Element &element, const Element &context)
{
    Q_D(const GenericPass);
    return PassManagerPrivate::visitor(*d->m_manager)
            ->addressableScopes()
            .id(QQmlJSScope::scope(element), QQmlJSScope::scope(context));
}
 
QString GenericPass::sourceCode(QQmlSA::SourceLocation location)
{
    Q_D(const GenericPass);
    return PassManagerPrivate::visitor(*d->m_manager)
            ->logger()
            ->code()
            .mid(location.offset(), location.length());
}
 
// explicitly defaulted out-of-line for PIMPL
PassManager::PassManager() = default;
PassManager::~PassManager() = default;
 
void PassManager::registerElementPass(std::unique_ptr<ElementPass> pass)
{
    Q_D(PassManager);
    d->registerElementPass(std::move(pass));
}
 
void PassManagerPrivate::registerElementPass(std::unique_ptr<ElementPass> pass)
{
    m_elementPasses.push_back(std::move(pass));
}
 
enum LookupMode { Register, Lookup };
static QString lookupName(const QQmlSA::Element &element, LookupMode mode = Lookup)
{
    QString name;
    if (element.isNull() || QQmlJSScope::scope(element)->internalName().isEmpty()) {
        // Bail out with an invalid name, this type is so screwed up we can't do anything reasonable
        // with it We should have warned about it in another plac
        if (element.isNull() || element.baseType().isNull())
            return u"$INVALID$"_s;
        name = QQmlJSScope::scope(element.baseType())->internalName();
    } else {
        name = QQmlJSScope::scope(element)->internalName();
    }
 
    const QString filePath =
            (mode == Register || !element.baseType() ? element : element.baseType()).filePath();
 
    if (QQmlJSScope::scope(element)->isComposite() && !filePath.endsWith(u".h"))
        name += u'@' + filePath;
    return name;
}
 
bool PassManager::registerPropertyPass(std::shared_ptr<PropertyPass> pass,
                                       QAnyStringView moduleName, QAnyStringView typeName,
                                       QAnyStringView propertyName, bool allowInheritance)
{
    Q_D(PassManager);
    return d->registerPropertyPass(pass, moduleName, typeName, propertyName, allowInheritance);
}
 
bool PassManagerPrivate::registerPropertyPass(std::shared_ptr<PropertyPass> pass,
                                              QAnyStringView moduleName, QAnyStringView typeName,
                                              QAnyStringView propertyName, bool allowInheritance)
{
    if (moduleName.isEmpty() != typeName.isEmpty()) {
        qWarning() << "Both the moduleName and the typeName must be specified "
                      "for the pass to be registered for a specific element.";
    }
 
    QString name;
    if (!moduleName.isEmpty() && !typeName.isEmpty()) {
        auto typeImporter = m_visitor->importer();
        auto module = typeImporter->importModule(moduleName.toString());
        auto element = QQmlJSScope::createQQmlSAElement(module.type(typeName.toString()).scope);
 
        if (element.isNull())
            return false;
 
        name = lookupName(element, Register);
    }
    const QQmlSA::PropertyPassInfo passInfo{ propertyName.isEmpty()
                                                     ? QStringList{}
                                                     : QStringList{ propertyName.toString() },
                                             std::move(pass), allowInheritance };
    m_propertyPasses.insert({ name, passInfo });
 
    return true;
}
 
void PassManagerPrivate::addBindingSourceLocations(const Element &element, const Element &scope,
                                                   const QString prefix, bool isAttached)
{
    const Element &currentScope = scope.isNull() ? element : scope;
    const auto ownBindings = currentScope.ownPropertyBindings();
    for (const auto &binding : ownBindings) {
        switch (binding.bindingType()) {
        case QQmlSA::BindingType::GroupProperty:
            addBindingSourceLocations(element, Element{ binding.groupType() },
                                      prefix + binding.propertyName() + u'.');
            break;
        case QQmlSA::BindingType::AttachedProperty:
            addBindingSourceLocations(element, Element{ binding.attachingType() },
                                      prefix + binding.propertyName() + u'.', true);
            break;
        default:
            m_bindingsByLocation.insert({ binding.sourceLocation().offset(),
                                          BindingInfo{ prefix + binding.propertyName(), binding,
                                                       currentScope, isAttached } });
 
            if (binding.bindingType() != QQmlSA::BindingType::Script)
                analyzeBinding(element, QQmlSA::Element(), binding.sourceLocation());
        }
    }
}
 
void PassManager::analyze(const Element &root)
{
    Q_D(PassManager);
    d->analyze(root);
}
 
static QQmlJS::ConstPtrWrapperIterator childScopesBegin(const Element &element)
{
    return QQmlJSScope::scope(element)->childScopesBegin();
}
 
static QQmlJS::ConstPtrWrapperIterator childScopesEnd(const Element &element)
{
    return QQmlJSScope::scope(element)->childScopesEnd();
}
 
void PassManagerPrivate::analyze(const Element &root)
{
    QList<Element> runStack;
    runStack.push_back(root);
    while (!runStack.isEmpty()) {
        auto element = runStack.takeLast();
        addBindingSourceLocations(element);
        for (auto &elementPass : m_elementPasses)
            if (elementPass->shouldRun(element))
                elementPass->run(element);
 
        for (auto it = childScopesBegin(element), end = childScopesEnd(element); it != end; ++it) {
            if ((*it)->scopeType() == QQmlSA::ScopeType::QMLScope)
                runStack.push_back(QQmlJSScope::createQQmlSAElement(*it));
        }
    }
}
 
void PassManagerPrivate::analyzeWrite(const Element &element, QString propertyName,
                                      const Element &value, const Element &writeScope,
                                      QQmlSA::SourceLocation location)
{
    for (PropertyPass *pass : findPropertyUsePasses(element, propertyName))
        pass->onWrite(element, propertyName, value, writeScope, location);
}
 
void PassManagerPrivate::analyzeRead(const Element &element, QString propertyName,
                                     const Element &readScope, QQmlSA::SourceLocation location)
{
    for (PropertyPass *pass : findPropertyUsePasses(element, propertyName))
        pass->onRead(element, propertyName, readScope, location);
}
 
void PassManagerPrivate::analyzeBinding(const Element &element, const QQmlSA::Element &value,
                                        QQmlSA::SourceLocation location)
{
    const auto info = m_bindingsByLocation.find(location.offset());
 
    // If there's no matching binding that means we're in a nested Ret somewhere inside an
    // expression
    if (info == m_bindingsByLocation.end())
        return;
 
    const QQmlSA::Element &bindingScope = info->second.bindingScope;
    const QQmlSA::Binding &binding = info->second.binding;
    const QString &propertyName = info->second.fullPropertyName;
 
    for (PropertyPass *pass : findPropertyUsePasses(element, propertyName))
        pass->onBinding(element, propertyName, binding, bindingScope, value);
 
    if (!info->second.isAttached || bindingScope.baseType().isNull())
        return;
 
    for (PropertyPass *pass : findPropertyUsePasses(bindingScope.baseType(), propertyName))
        pass->onBinding(element, propertyName, binding, bindingScope, value);
}
 
bool PassManager::hasImportedModule(QAnyStringView module) const
{
    return PassManagerPrivate::visitor(*this)->imports().hasType(u"$module$." + module.toString());
}
 
bool PassManager::isCategoryEnabled(LoggerWarningId category) const
{
    return !PassManagerPrivate::visitor(*this)->logger()->isCategoryIgnored(category);
}
 
QQmlJSImportVisitor *QQmlSA::PassManagerPrivate::visitor(const QQmlSA::PassManager &manager)
{
    return manager.d_func()->m_visitor;
}
 
QQmlJSTypeResolver *QQmlSA::PassManagerPrivate::resolver(const QQmlSA::PassManager &manager)
{
    return manager.d_func()->m_typeResolver;
}
 
QSet<PropertyPass *> PassManagerPrivate::findPropertyUsePasses(const QQmlSA::Element &element,
                                                               const QString &propertyName)
{
    QStringList typeNames { lookupName(element) };
 
    QQmlJSUtils::searchBaseAndExtensionTypes(
            QQmlJSScope::scope(element),
            [&](const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ExtensionKind mode) {
                Q_UNUSED(mode);
                typeNames.append(lookupName(QQmlJSScope::createQQmlSAElement(scope)));
                return false;
            });
 
    QSet<PropertyPass *> passes;
 
    for (const QString &typeName : typeNames) {
        for (auto &pass :
             { m_propertyPasses.equal_range(u""_s), m_propertyPasses.equal_range(typeName) }) {
            if (pass.first == pass.second)
                continue;
 
            for (auto it = pass.first; it != pass.second; it++) {
                if (typeName != typeNames.constFirst() && !it->second.allowInheritance)
                    continue;
                if (it->second.properties.isEmpty()
                    || it->second.properties.contains(propertyName)) {
                    passes.insert(it->second.pass.get());
                }
            }
        }
    }
    return passes;
}
 
void DebugElementPass::run(const Element &element) {
    emitWarning(u"Type: " + element.baseTypeName(), qmlPlugin);
    if (auto bindings = element.propertyBindings(u"objectName"_s); !bindings.isEmpty()) {
        emitWarning(u"is named: " + bindings.first().stringValue(), qmlPlugin);
    }
    if (auto defPropName = element.defaultPropertyName(); !defPropName.isEmpty()) {
        emitWarning(u"binding " + QString::number(element.propertyBindings(defPropName).size())
                            + u" elements to property "_s + defPropName,
                    qmlPlugin);
    }
}
 
bool ElementPass::shouldRun(const Element &element)
{
    (void)element;
    return true;
}
 
PropertyPass::PropertyPass(PassManager *manager) : GenericPass(manager) { }
void PropertyPass::onBinding(const Element &element, const QString &propertyName,
                             const QQmlSA::Binding &binding, const Element &bindingScope,
                             const Element &value)
{
    Q_UNUSED(element);
    Q_UNUSED(propertyName);
    Q_UNUSED(binding);
    Q_UNUSED(bindingScope);
    Q_UNUSED(value);
}
 
void PropertyPass::onRead(const Element &element, const QString &propertyName,
                          const Element &readScope, QQmlSA::SourceLocation location)
{
    Q_UNUSED(element);
    Q_UNUSED(propertyName);
    Q_UNUSED(readScope);
    Q_UNUSED(location);
}
 
void PropertyPass::onWrite(const Element &element, const QString &propertyName,
                           const Element &expressionType, const Element &writeScope,
                           QQmlSA::SourceLocation location)
{
    Q_UNUSED(element);
    Q_UNUSED(propertyName);
    Q_UNUSED(writeScope);
    Q_UNUSED(expressionType);
    Q_UNUSED(location);
}
 
DebugPropertyPass::DebugPropertyPass(QQmlSA::PassManager *manager) : QQmlSA::PropertyPass(manager)
{
}
 
void DebugPropertyPass::onRead(const QQmlSA::Element &element, const QString &propertyName,
                               const QQmlSA::Element &readScope, QQmlSA::SourceLocation location)
{
    emitWarning(u"onRead "_s
                        + (QQmlJSScope::scope(element)->internalName().isEmpty()
                                   ? element.baseTypeName()
                                   : QQmlJSScope::scope(element)->internalName())
                        + u' ' + propertyName + u' ' + QQmlJSScope::scope(readScope)->internalName()
                        + u' ' + QString::number(location.startLine()) + u':'
                        + QString::number(location.startColumn()),
                qmlPlugin, location);
}
 
void DebugPropertyPass::onBinding(const QQmlSA::Element &element, const QString &propertyName,
                                  const QQmlSA::Binding &binding,
                                  const QQmlSA::Element &bindingScope, const QQmlSA::Element &value)
{
    const auto location = QQmlSA::SourceLocation{ binding.sourceLocation() };
    emitWarning(u"onBinding element: '"_s
                        + (QQmlJSScope::scope(element)->internalName().isEmpty()
                                   ? element.baseTypeName()
                                   : QQmlJSScope::scope(element)->internalName())
                        + u"' property: '"_s + propertyName + u"' value: '"_s
                        + (value.isNull() ? u"NULL"_s
                                          : (QQmlJSScope::scope(value)->internalName().isNull()
                                                     ? value.baseTypeName()
                                                     : QQmlJSScope::scope(value)->internalName()))
                        + u"' binding_scope: '"_s
                        + (QQmlJSScope::scope(bindingScope)->internalName().isEmpty()
                                   ? bindingScope.baseTypeName()
                                   : QQmlJSScope::scope(bindingScope)->internalName())
                        + u"' "_s + QString::number(location.startLine()) + u':'
                        + QString::number(location.startColumn()),
                qmlPlugin, location);
}
 
void DebugPropertyPass::onWrite(const QQmlSA::Element &element, const QString &propertyName,
                                const QQmlSA::Element &value, const QQmlSA::Element &writeScope,
                                QQmlSA::SourceLocation location)
{
    emitWarning(u"onWrite "_s + element.baseTypeName() + u' ' + propertyName + u' '
                        + QQmlJSScope::scope(value)->internalName() + u' '
                        + QQmlJSScope::scope(writeScope)->internalName() + u' '
                        + QString::number(location.startLine()) + u':'
                        + QString::number(location.startColumn()),
                qmlPlugin, location);
}
 
std::vector<std::shared_ptr<ElementPass>> PassManager::elementPasses() const
{
    Q_D(const PassManager);
    return d->m_elementPasses;
}
 
std::multimap<QString, PropertyPassInfo> PassManager::propertyPasses() const
{
    Q_D(const PassManager);
    return d->m_propertyPasses;
}
 
std::unordered_map<quint32, BindingInfo> PassManager::bindingsByLocation() const
{
    Q_D(const PassManager);
    return d->m_bindingsByLocation;
}
 
FixSuggestionPrivate::FixSuggestionPrivate(FixSuggestion *interface) : q_ptr{ interface } { }
 
FixSuggestionPrivate::FixSuggestionPrivate(FixSuggestion *interface, const QString &fixDescription,
                                           const QQmlSA::SourceLocation &location,
                                           const QString &replacement)
    : m_fixSuggestion{ fixDescription, QQmlSA::SourceLocationPrivate::sourceLocation(location),
                       replacement },
      q_ptr{ interface }
{
}
 
FixSuggestionPrivate::FixSuggestionPrivate(FixSuggestion *interface,
                                           const FixSuggestionPrivate &other)
    : m_fixSuggestion{ other.m_fixSuggestion }, q_ptr{ interface }
{
}
 
FixSuggestionPrivate::FixSuggestionPrivate(FixSuggestion *interface, FixSuggestionPrivate &&other)
    : m_fixSuggestion{ std::move(other.m_fixSuggestion) }, q_ptr{ interface }
{
}
 
QString FixSuggestionPrivate::fixDescription() const
{
    return m_fixSuggestion.fixDescription();
}
 
QQmlSA::SourceLocation FixSuggestionPrivate::location() const
{
    return QQmlSA::SourceLocationPrivate::createQQmlSASourceLocation(m_fixSuggestion.location());
}
 
QString FixSuggestionPrivate::replacement() const
{
    return m_fixSuggestion.replacement();
}
 
void FixSuggestionPrivate::setFileName(const QString &fileName)
{
    m_fixSuggestion.setFilename(fileName);
}
 
QString FixSuggestionPrivate::fileName() const
{
    return m_fixSuggestion.filename();
}
 
void FixSuggestionPrivate::setHint(const QString &hint)
{
    m_fixSuggestion.setHint(hint);
}
 
QString FixSuggestionPrivate::hint() const
{
    return m_fixSuggestion.hint();
}
 
void FixSuggestionPrivate::setAutoApplicable(bool autoApplicable)
{
    m_fixSuggestion.setAutoApplicable(autoApplicable);
}
 
bool FixSuggestionPrivate::isAutoApplicable() const
{
    return m_fixSuggestion.isAutoApplicable();
}
 
QQmlJSFixSuggestion &FixSuggestionPrivate::fixSuggestion(FixSuggestion &saFixSuggestion)
{
    return saFixSuggestion.d_func()->m_fixSuggestion;
}
 
const QQmlJSFixSuggestion &FixSuggestionPrivate::fixSuggestion(const FixSuggestion &saFixSuggestion)
{
    return saFixSuggestion.d_func()->m_fixSuggestion;
}
 
FixSuggestion::FixSuggestion(const QString &fixDescription, const QQmlSA::SourceLocation &location,
                             const QString &replacement)
    : d_ptr{ new FixSuggestionPrivate{ this, fixDescription, location, replacement } }
{
}
 
FixSuggestion::FixSuggestion(const FixSuggestion &other)
    : d_ptr{ new FixSuggestionPrivate{ this, *other.d_func() } }
{
}
 
FixSuggestion::FixSuggestion(FixSuggestion &&other) noexcept
    : d_ptr{ new FixSuggestionPrivate{ this, std::move(*other.d_func()) } }
{
}
 
FixSuggestion &FixSuggestion::operator=(const FixSuggestion &other)
{
    if (*this == other)
        return *this;
 
    d_func()->m_fixSuggestion = other.d_func()->m_fixSuggestion;
    return *this;
}
 
FixSuggestion &FixSuggestion::operator=(FixSuggestion &&other) noexcept
{
    if (*this == other)
        return *this;
 
    d_func()->m_fixSuggestion = std::move(other.d_func()->m_fixSuggestion);
    return *this;
}
 
FixSuggestion::~FixSuggestion() = default;
 
QString QQmlSA::FixSuggestion::fixDescription() const
{
    return FixSuggestionPrivate::fixSuggestion(*this).fixDescription();
}
 
QQmlSA::SourceLocation FixSuggestion::location() const
{
    return QQmlSA::SourceLocationPrivate::createQQmlSASourceLocation(
            FixSuggestionPrivate::fixSuggestion(*this).location());
}
 
QString FixSuggestion::replacement() const
{
    return FixSuggestionPrivate::fixSuggestion(*this).replacement();
}
 
void FixSuggestion::setFileName(const QString &fileName)
{
    FixSuggestionPrivate::fixSuggestion(*this).setFilename(fileName);
}
 
QString FixSuggestion::fileName() const
{
    return FixSuggestionPrivate::fixSuggestion(*this).filename();
}
 
void FixSuggestion::setHint(const QString &hint)
{
    FixSuggestionPrivate::fixSuggestion(*this).setHint(hint);
}
 
QString FixSuggestion::hint() const
{
    return FixSuggestionPrivate::fixSuggestion(*this).hint();
}
 
void FixSuggestion::setAutoApplicable(bool autoApplicable)
{
    return FixSuggestionPrivate::fixSuggestion(*this).setAutoApplicable(autoApplicable);
}
 
bool QQmlSA::FixSuggestion::isAutoApplicable() const
{
    return FixSuggestionPrivate::fixSuggestion(*this).isAutoApplicable();
}
 
bool FixSuggestion::operatorEqualsImpl(const FixSuggestion &lhs, const FixSuggestion &rhs)
{
    return lhs.d_func()->m_fixSuggestion == rhs.d_func()->m_fixSuggestion;
}
 
} // namespace QQmlSA
 
QT_END_NAMESPACE