qqmljsimportvisitor.cpp

++ // Copyright (C) 2019 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++ // Qt-Security score:significant

++

++ #include "qqmljsimportvisitor_p.h"

++ #include "qqmljslogger_p.h"

++ #include "qqmljsmetatypes_p.h"

++ #include "qqmljsresourcefilemapper_p.h"

++

++ #include <QtCore/qdir.h>

++ #include <QtCore/qqueue.h>

++ #include <QtCore/qscopedvaluerollback.h>

++ #include <QtCore/qpoint.h>

++ #include <QtCore/qrect.h>

++ #include <QtCore/qsize.h>

++

++ #include <QtQml/private/qqmlsignalnames_p.h>

++ #include <QtQml/private/qv4codegen_p.h>

++ #include <QtQml/private/qqmlstringconverters_p.h>

++ #include <QtQml/private/qqmlirbuilder_p.h>

++ #include "qqmljsscope_p.h"

++ #include "qqmljsutils_p.h"

++ #include "qqmljsloggingutils.h"

++ #include "qqmlsaconstants.h"

++

++ #include <QtCore/qtyperevision.h>

++

++ #include <algorithm>

++ #include <limits>

++ #include <optional>

++ #include <variant>

++

++ QT_BEGIN_NAMESPACE

++

++ using namespace Qt::StringLiterals;

++

++ using namespace QQmlJS::AST;

++

++ static const QLatin1StringView wasNotFound

++         = "was not found."_L1;

++

++ /*!

++     \internal

++     Returns if assigning \a assignedType to \a property would require an

++     implicit component wrapping.

++  */

++ static bool causesImplicitComponentWrapping(const QQmlJSMetaProperty &property,

++                                                   const QQmlJSScope::ConstPtr &assignedType)

++ {

++     // See QQmlComponentAndAliasResolver::findAndRegisterImplicitComponents()

++     // for the logic in qqmltypecompiler

++

++     // Note: unlike findAndRegisterImplicitComponents() we do not check whether

++     // the property type is *derived* from QQmlComponent at some point because

++     // this is actually meaningless (and in the case of QQmlComponent::create()

++     // gets rejected in QQmlPropertyValidator): if the type is not a

++     // QQmlComponent, we have a type mismatch because of assigning a Component

++     // object to a non-Component property

++     const bool propertyVerdict = property.type()->internalName() == u"QQmlComponent";

++

++     const bool assignedTypeVerdict = [&assignedType]() {

++         // Note: nonCompositeBaseType covers the case when assignedType itself

++         // is non-composite

++         auto cppBase = QQmlJSScope::nonCompositeBaseType(assignedType);

++         Q_ASSERT(cppBase); // any QML type has (or must have) a C++ base type

++

++         // See isUsableComponent() in qqmltypecompiler.cpp: along with checking

++         // whether a type has a QQmlComponent static meta object (which we

++         // substitute here with checking the first non-composite base for being

++         // a QQmlComponent), it also excludes QQmlAbstractDelegateComponent

++         // subclasses from implicit wrapping

++         if (cppBase->internalName() == u"QQmlComponent")

++             return false;

++         for (; cppBase; cppBase = cppBase->baseType()) {

++             if (cppBase->internalName() == u"QQmlAbstractDelegateComponent")

++                 return false;

++         }

++         return true;

++     }();

++

++     return propertyVerdict && assignedTypeVerdict;

++ }

++

++ /*!

++   \internal

++   A guarded version of insertJSIdentifier. If the scope is a QML scope,

++   it will log a syntax error instead.

++   Returns true if insertion was successful, otherwise false

++  */

++ bool QQmlJSImportVisitor::safeInsertJSIdentifier(QQmlJSScope::Ptr &scope, const QString &name,

++                                    const QQmlJSScope::JavaScriptIdentifier &identifier)

++ {

++   /* The grammar currently allows putting a variable declaration into a UiObjectMember

++      and we only complain about it in the IRBbuilder. It is unclear whether we should change

++      the grammar, as the linter would need to handle invalid programs anyway, so we'd need

++      to add some recovery rule to the grammar in any case.

++      We use this method instead to avoid an assertion in insertJSIdentifier

++   */

++     if (scope->scopeType() == QQmlSA::ScopeType::QMLScope)

++       return false;

++     scope->insertJSIdentifier(name, identifier);

++     return true;

++ }

++

++ /*!

++   \internal

++   Sets the name of \a scope to \a name based on \a type.

++ */

++ void QQmlJSImportVisitor::setScopeName(QQmlJSScope::Ptr &scope, QQmlJSScope::ScopeType type,

++                                        const QString &name)

++ {

++     Q_ASSERT(scope);

++     switch (type) {

++     case QQmlSA::ScopeType::GroupedPropertyScope:

++         scope->setInternalName(name);

++         return;

++     case QQmlSA::ScopeType::AttachedPropertyScope:

++         scope->setInternalName(name);

++         scope->setBaseTypeName(name);

++         QQmlJSScope::resolveTypes(scope, m_rootScopeImports.contextualTypes(), usedTypes());

++         return;

++     case QQmlSA::ScopeType::QMLScope:

++         scope->setBaseTypeName(name);

++         QQmlJSScope::resolveTypes(scope, m_rootScopeImports.contextualTypes(), usedTypes());

++         return;

++     case QQmlSA::ScopeType::JSFunctionScope:

++     case QQmlSA::ScopeType::BindingFunctionScope:

++     case QQmlSA::ScopeType::SignalHandlerFunctionScope:

++     case QQmlSA::ScopeType::JSLexicalScope:

++     case QQmlSA::ScopeType::EnumScope:

++         scope->setBaseTypeName(name);

++         return;

++     };

++ }

++

++ template<typename Node>

++ QString buildName(const Node *node)

++ {

++     QString result;

++     for (const Node *segment = node; segment; segment = segment->next) {

++         if (!result.isEmpty())

++             result += u'.';

++         result += segment->name;

++     }

++     return result;

++ }

++

++ QQmlJSImportVisitor::QQmlJSImportVisitor(QQmlJSImporter *importer, QQmlJSLogger *logger,

++                                          const QString &implicitImportDirectory,

++                                          const QStringList &qmldirFiles)

++     : m_implicitImportDirectory(implicitImportDirectory),

++       m_qmldirFiles(qmldirFiles),

++       m_exportedRootScope(QQmlJSScope::resetForReparse(importer->importFile(logger->filePath()))),

++       m_importer(importer),

++       m_logger(logger),

++       m_rootScopeImports(QQmlJS::ContextualTypes(

++                                  QQmlJS::ContextualTypes::QML, { }, { },

++                                  importer->builtinInternalNames().contextualTypes().arrayType()),

++                          { })

++ {

++     Q_ASSERT(logger); // must be valid

++     Q_ASSERT(importer); // must be valid

++

++     m_exportedRootScope->setScopeType(QQmlSA::ScopeType::QMLScope);

++     m_exportedRootScope->setBaseTypeName(QQmlJSImporter::s_inProcessMarker);

++     m_exportedRootScope->setFilePath(m_logger->filePath());

++     m_exportedRootScope->setIsComposite(true);

++

++     /* FIXME:

++        we create a "local global object" – this prevents any modification of the actual global object;

++        That's necessary because scopes track child scopes, and we don't want to do any shared modifications.

++        However, if we were to allow that the global object doesn't track the child scopes, we could move

++        the global object scope into the type resolver instead.

++     */

++     auto globalScope = QQmlJSScope::create();

++     globalScope->setInternalName(u"global"_s);

++     globalScope->setScopeType(QQmlSA::ScopeType::JSFunctionScope);

++

++     QQmlJSScope::JavaScriptIdentifier globalJavaScript = {

++         QQmlJSScope::JavaScriptIdentifier::LexicalScoped, QQmlJS::SourceLocation(), std::nullopt,

++         true

++     };

++

++     QV4::Compiler::Codegen::forEachGlobalName([&](QLatin1StringView globalName) {

++         globalScope->insertJSIdentifier(globalName, globalJavaScript);

++     });

++

++     m_globalScope = globalScope;

++     m_currentScope = globalScope;

++ }

++

++ QQmlJSImportVisitor::~QQmlJSImportVisitor() = default;

++

++ void QQmlJSImportVisitor::populateCurrentScope(

++         QQmlJSScope::ScopeType type, const QString &name, const QQmlJS::SourceLocation &location)

++ {

++     m_currentScope->setScopeType(type);

++     m_currentScope->setIsComposite(true);

++     m_currentScope->setFilePath(m_logger->filePath());

++     m_currentScope->setSourceLocation(location);

++     setScopeName(m_currentScope, type, name);

++     m_scopesByIrLocation.insert({ location.startLine, location.startColumn }, m_currentScope);

++ }

++

++ void QQmlJSImportVisitor::enterRootScope(QQmlJSScope::ScopeType type, const QString &name, const QQmlJS::SourceLocation &location)

++ {

++     Q_ASSERT(m_currentScope == m_globalScope);

++     QQmlJSScope::reparent(m_currentScope, m_exportedRootScope);

++     m_currentScope = m_exportedRootScope;

++     populateCurrentScope(type, name, location);

++ }

++

++ void QQmlJSImportVisitor::enterEnvironment(QQmlJSScope::ScopeType type, const QString &name,

++                                            const QQmlJS::SourceLocation &location)

++ {

++     QQmlJSScope::Ptr newScope = QQmlJSScope::create();

++     QQmlJSScope::reparent(m_currentScope, newScope);

++     m_currentScope = std::move(newScope);

++     populateCurrentScope(type, name, location);

++ }

++

++ bool QQmlJSImportVisitor::enterEnvironmentNonUnique(QQmlJSScope::ScopeType type,

++                                                     const QString &name,

++                                                     const QQmlJS::SourceLocation &location)

++ {

++     Q_ASSERT(type == QQmlSA::ScopeType::GroupedPropertyScope

++              || type == QQmlSA::ScopeType::AttachedPropertyScope);

++

++     const auto pred = [&](const QQmlJSScope::ConstPtr &s) {

++         // it's either attached or grouped property, so use internalName()

++         // directly. see setScopeName() for details

++         return s->internalName() == name;

++     };

++     const auto scopes = m_currentScope->childScopes();

++     // TODO: linear search. might want to make childScopes() a set/hash-set and

++     // use faster algorithm here

++     auto it = std::find_if(scopes.begin(), scopes.end(), pred);

++     if (it == scopes.end()) {

++         // create and enter new scope

++         enterEnvironment(type, name, location);

++         return false;

++     }

++     // enter found scope

++     m_scopesByIrLocation.insert({ location.startLine, location.startColumn }, *it);

++     m_currentScope = *it;

++     return true;

++ }

++

++ void QQmlJSImportVisitor::leaveEnvironment()

++ {

++     m_currentScope = m_currentScope->parentScope();

++ }

++

++ void QQmlJSImportVisitor::warnUnresolvedType(const QQmlJSScope::ConstPtr &type) const

++ {

++     m_logger->log(QStringLiteral("Type %1 is used but it is not resolved")

++                           .arg(QQmlJSUtils::getScopeName(type, type->scopeType())),

++                           qmlUnresolvedType, type->sourceLocation());

++ }

++

++ void QQmlJSImportVisitor::warnMissingPropertyForBinding(

++         const QString &property, const QQmlJS::SourceLocation &location,

++         const std::optional<QQmlJSFixSuggestion> &fixSuggestion)

++ {

++     m_logger->log(QStringLiteral("Could not find property \"%1\".").arg(property),

++                   qmlMissingProperty, location, true, true, fixSuggestion);

++ }

++

++ static bool mayBeUnresolvedGroupedProperty(const QQmlJSScope::ConstPtr &scope)

++ {

++     return scope->scopeType() == QQmlSA::ScopeType::GroupedPropertyScope && !scope->baseType();

++ }

++

++ QQmlJSImportVisitor::AliasPropertyResolution

++ QQmlJSImportVisitor::resolveAliasProperty(const QQmlJSScope::Ptr &object,

++                                           const QQmlJSMetaProperty &property)

++ {

++     AliasPropertyResolution result = Resolved;

++     QStringList components = property.aliasExpression().split(u'.');

++     QQmlJSMetaProperty targetProperty;

++

++     bool foundProperty = false;

++     bool hasWarnedAlready = false;

++

++     // The first component has to be an ID. Find the object it refers to.

++     QQmlJSScope::ConstPtr type = m_scopesById.scope(components.takeFirst(), object);

++     QQmlJSScope::ConstPtr typeScope;

++     if (!type.isNull()) {

++         foundProperty = true;

++

++         // Any further components are nested properties of that object.

++         // Technically we can only resolve a limited depth in the engine, but the rules

++         // on that are fuzzy and subject to change. Let's ignore it for now.

++         // If the target is itself an alias and has not been resolved, re-queue the object

++         // and try again later.

++         while (type && !components.isEmpty()) {

++             const QString name = components.takeFirst();

++

++             if (!checkTypeResolved(type)) {

++                 hasWarnedAlready = true;

++                 type = { };

++                 break;

++             }

++

++             if (!type->hasProperty(name)) {

++                 foundProperty = false;

++                 type = { };

++                 break;

++             }

++

++             const auto target = type->property(name);

++             if (!target.type()) {

++                 if (target.isAlias()) {

++                     result = NeedsRequeue;

++                 } else {

++                     // We already warned about the missing type in the property definition if

++                     // the type is defined in this QML file.

++                     hasWarnedAlready = QQmlJSScope::ownerOfProperty(type, name).scope->filePath()

++                             == m_exportedRootScope->filePath();

++                 }

++             }

++             typeScope = type;

++             type = target.type();

++             targetProperty = target;

++         }

++     }

++

++     if (type.isNull()) {

++         if (result == NeedsRequeue)

++             return result;

++         if (!hasWarnedAlready) {

++             if (foundProperty) {

++                 m_logger->log(QStringLiteral("Cannot deduce type of alias \"%1\"")

++                                       .arg(property.propertyName()),

++                               qmlMissingType, property.sourceLocation());

++             } else {

++                 m_logger->log(

++                         QStringLiteral("Cannot resolve alias \"%1\"").arg(property.propertyName()),

++                         qmlUnresolvedAlias, property.sourceLocation());

++             }

++         }

++

++         Q_ASSERT(property.index() >= 0); // this property is already in object

++         object->addOwnProperty(property);

++

++     } else {

++         QQmlJSMetaProperty newProperty = property;

++         newProperty.setType(type);

++         // Copy additional property information from target

++         newProperty.setIsList(targetProperty.isList());

++         newProperty.setIsWritable(targetProperty.isWritable());

++         newProperty.setIsFinal(targetProperty.isFinal());

++         newProperty.setIsPointer(targetProperty.isPointer());

++

++         const bool onlyId = !property.aliasExpression().contains(u'.');

++         if (onlyId) {

++             newProperty.setAliasTargetScope(type);

++             newProperty.setAliasTargetName(QStringLiteral("id-only-alias"));

++         } else {

++             const auto &ownerScope =

++                     QQmlJSScope::ownerOfProperty(typeScope, targetProperty.propertyName()).scope;

++             newProperty.setAliasTargetScope(ownerScope);

++             newProperty.setAliasTargetName(targetProperty.propertyName());

++         }

++

++         if (const QString internalName = type->internalName(); !internalName.isEmpty())

++             newProperty.setTypeName(internalName);

++

++         Q_ASSERT(newProperty.index() >= 0); // this property is already in object

++         object->addOwnProperty(newProperty);

++         m_aliasDefinitions.append({ object, property.propertyName() });

++     }

++     return result;

++ }

++

++ void QQmlJSImportVisitor::resolveAliases()

++ {

++     QQueue<QQmlJSScope::Ptr> objects;

++     objects.enqueue(m_exportedRootScope);

++

++     qsizetype lastRequeueLength = std::numeric_limits<qsizetype>::max();

++     QQueue<QQmlJSScope::Ptr> requeue;

++     QDuplicateTracker<std::pair<QQmlJSScope::Ptr, QQmlJSMetaProperty>> alreadyResolvedAliases;

++

++     bool processingRequeue = false;

++

++     while (!objects.isEmpty()) {

++         const QQmlJSScope::Ptr object = objects.dequeue();

++         const auto properties = object->ownProperties();

++

++         bool doRequeue = false;

++         for (const auto &property : properties) {

++             if (!property.isAlias() || !property.type().isNull()

++                 || alreadyResolvedAliases.contains({ object, property })) {

++                 continue;

++             }

++             if (resolveAliasProperty(object, property) == NeedsRequeue) {

++                 doRequeue = true;

++             } else {

++                 Q_UNUSED(alreadyResolvedAliases.hasSeen({ object, property }));

++             }

++         }

++

++         if (!processingRequeue) {

++             const auto childScopes = object->childScopes();

++             for (const auto &childScope : childScopes)

++                 objects.enqueue(childScope);

++         }

++

++         if (doRequeue)

++             requeue.enqueue(object);

++

++         if (objects.isEmpty() && requeue.size() < lastRequeueLength) {

++             processingRequeue = true;

++             lastRequeueLength = requeue.size();

++             objects.swap(requeue);

++         }

++     }

++

++     while (!requeue.isEmpty()) {

++         const QQmlJSScope::Ptr object = requeue.dequeue();

++         const auto properties = object->ownProperties();

++         for (const auto &property : properties) {

++             if (!property.isAlias() || !property.type().isNull()

++                 || alreadyResolvedAliases.contains({ object, property })) {

++                 continue;

++             }

++             m_logger->log(QStringLiteral("Alias \"%1\" is part of an alias cycle")

++                                   .arg(property.propertyName()),

++                           qmlAliasCycle, property.sourceLocation());

++         }

++     }

++ }

++

++ void QQmlJSImportVisitor::resolveGroupedProperties()

++ {

++     QQueue<QQmlJSScope::Ptr> objects;

++     objects.enqueue(m_exportedRootScope);

++

++     while (!objects.isEmpty()) {

++         const QQmlJSScope::Ptr object = objects.dequeue();

++         const auto childScopes = object->childScopes();

++         for (const auto &childScope : childScopes) {

++             if (mayBeUnresolvedGroupedProperty(childScope)) {

++                 const QString name = childScope->internalName();

++                 if (object->isNameDeferred(name)) {

++                     const QQmlJSScope::ConstPtr deferred = m_scopesById.scope(name, childScope);

++                     if (!deferred.isNull()) {

++                         QQmlJSScope::resolveGroup(childScope, deferred,

++                                                   m_rootScopeImports.contextualTypes(),

++                                                   usedTypes());

++                     }

++                 } else if (const QQmlJSScope::ConstPtr propType = object->property(name).type()) {

++                     QQmlJSScope::resolveGroup(childScope, propType,

++                                               m_rootScopeImports.contextualTypes(), usedTypes());

++                 }

++             }

++             objects.enqueue(childScope);

++         }

++     }

++ }

++

++ QString QQmlJSImportVisitor::implicitImportDirectory(const QString &localFile,

++                                                      const QQmlJSResourceFileMapper *mapper)

++ {

++     if (mapper) {

++         const auto resource = mapper->entry(

++                     QQmlJSResourceFileMapper::localFileFilter(localFile));

++         if (resource.isValid()) {

++             return resource.resourcePath.contains(u'/')

++                     ? (u':' + resource.resourcePath.left(

++                            resource.resourcePath.lastIndexOf(u'/') + 1))

++                     : QStringLiteral(":/");

++         }

++     }

++

++     return QFileInfo(localFile).canonicalPath() + u'/';

++ }

++

++ void QQmlJSImportVisitor::processImportWarnings(

++         const QString &what, const QList<QQmlJS::DiagnosticMessage> &warnings,

++         const QQmlJS::SourceLocation &srcLocation)

++ {

++     if (warnings.isEmpty())

++         return;

++

++     QList<QQmlJS::DiagnosticMessage> importWarnings = warnings;

++

++     // if we have file selector warnings, they are marked by a lower priority

++     auto fileSelectorWarningsIt = std::partition(importWarnings.begin(), importWarnings.end(),

++                                                  [](const QQmlJS::DiagnosticMessage &message) {

++                                                      return message.type != QtMsgType::QtInfoMsg;

++                                                  });

++     if (fileSelectorWarningsIt != importWarnings.end()) {

++         m_logger->log(QStringLiteral("Warnings occurred while importing %1:").arg(what), qmlImportFileSelector,

++                       srcLocation);

++         m_logger->processMessages(QSpan(fileSelectorWarningsIt, importWarnings.end()),

++                                   qmlImportFileSelector, srcLocation);

++     }

++

++     if (fileSelectorWarningsIt == importWarnings.begin())

++         return;

++

++     m_logger->log(QStringLiteral("Warnings occurred while importing %1:").arg(what), qmlImport,

++                   srcLocation);

++     m_logger->processMessages(QSpan(importWarnings.begin(), fileSelectorWarningsIt), qmlImport,

++                               srcLocation);

++ }

++

++ void QQmlJSImportVisitor::importBaseModules()

++ {

++     Q_ASSERT(m_rootScopeImports.isEmpty());

++     m_rootScopeImports = m_importer->importHardCodedBuiltins();

++     /* Pass the file's selector along so we have a consistent view on selectors:

++        - If there is a file selector, we only consider non-file-selected files and those

++          using the same selector. Reality is more complicated, but this should be enoguh

++          for most projects.

++        - If the current file is not using a file selector, we consider everything

++      */

++     m_rootScopeImports.setCurrentFileSelector(

++             QQmlJSUtils::fileSelectorFor(m_exportedRootScope));

++

++     const QQmlJS::SourceLocation invalidLoc;

++     const auto types = m_rootScopeImports.types();

++     for (auto it = types.keyBegin(), end = types.keyEnd(); it != end; it++)

++         addImportWithLocation(*it, invalidLoc, false);

++

++     if (!m_qmldirFiles.isEmpty())

++         m_rootScopeImports.addWarnings(m_importer->importQmldirs(m_qmldirFiles));

++

++     // Pulling in the modules and neighboring qml files of the qmltypes we're trying to lint is not

++     // something we need to do.

++     if (!m_logger->filePath().endsWith(u".qmltypes"_s)) {

++         auto precedence = quint8(QQmlJS::PrecedenceValues::ImplicitImport);

++         auto implicitImport = m_importer->importDirectory(m_implicitImportDirectory, precedence);

++         m_importer->registerVersionedImports(implicitImport);

++         m_rootScopeImports.add(std::move(implicitImport));

++

++         // Import all possible resource directories the file may belong to.

++         // This is somewhat fuzzy, but if you're mapping the same file to multiple resource

++         // locations, you're on your own anyway.

++         if (const QQmlJSResourceFileMapper *mapper = m_importer->resourceFileMapper()) {

++             const QStringList resourcePaths = mapper->resourcePaths(QQmlJSResourceFileMapper::Filter {

++                     m_logger->filePath(), QStringList(), QQmlJSResourceFileMapper::Resource });

++             for (const QString &path : resourcePaths) {

++                 const qsizetype lastSlash = path.lastIndexOf(QLatin1Char('/'));

++                 if (lastSlash == -1)

++                     continue;

++                 auto precedence = quint8(QQmlJS::PrecedenceValues::ImplicitImport);

++                 auto resourceImport =

++                         m_importer->importDirectory(path.first(lastSlash), precedence);

++                 m_importer->registerVersionedImports(resourceImport);

++                 m_rootScopeImports.add(std::move(resourceImport));

++             }

++         }

++     }

++

++     processImportWarnings(QStringLiteral("base modules"), m_rootScopeImports.warnings());

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiProgram *)

++ {

++     importBaseModules();

++     // if the current file  is a QML file, make it available, too

++     if (auto elementName = QFileInfo(m_logger->filePath()).baseName();

++         !elementName.isEmpty() && elementName[0].isUpper()) {

++         auto precedence = quint8(QQmlJS::PrecedenceValues::ImplicitImport);

++         m_rootScopeImports.setType(elementName,

++                                    { m_exportedRootScope, QTypeRevision{ }, precedence });

++     }

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(UiProgram *)

++ {

++     for (const auto &scope : std::as_const(m_objectBindingScopes)) {

++         breakInheritanceCycles(scope);

++         checkDeprecation(scope);

++         checkForComponentTypeWithProperties(scope);

++     }

++

++     for (const auto &scope : std::as_const(m_objectDefinitionScopes)) {

++         if (m_pendingDefaultProperties.contains(scope))

++             continue; // We're going to check this one below.

++         breakInheritanceCycles(scope);

++         checkDeprecation(scope);

++         checkForComponentTypeWithProperties(scope);

++     }

++

++     const auto &keys = m_pendingDefaultProperties.keys();

++     for (const auto &scope : keys) {

++         breakInheritanceCycles(scope);

++         checkDeprecation(scope);

++         checkForComponentTypeWithProperties(scope);

++     }

++

++     resolveAliases();

++     resolveGroupedProperties();

++

++     checkGroupedAndAttachedScopes();

++

++     setAllBindings();

++     processDefaultProperties();

++     processPropertyTypes();

++     processMethodTypes();

++     processPropertyBindings();

++     processPropertyBindingObjects();

++     checkRequiredProperties();

++

++     populateRuntimeFunctionIndicesForDocument();

++ }

++

++ static QQmlJSAnnotation::Value bindingToVariant(QQmlJS::AST::Statement *statement)

++ {

++     ExpressionStatement *expr = cast<ExpressionStatement *>(statement);

++

++     if (!statement || !expr->expression)

++         return {};

++

++     switch (expr->expression->kind) {

++     case Node::Kind_StringLiteral:

++         return cast<StringLiteral *>(expr->expression)->value.toString();

++     case Node::Kind_NumericLiteral:

++         return cast<NumericLiteral *>(expr->expression)->value;

++     default:

++         return {};

++     }

++ }

++

++ QList<QQmlJSAnnotation> QQmlJSImportVisitor::parseAnnotations(QQmlJS::AST::UiAnnotationList *list)

++ {

++

++     QList<QQmlJSAnnotation> annotationList;

++

++     for (UiAnnotationList *item = list; item != nullptr; item = item->next) {

++         UiAnnotation *annotation = item->annotation;

++

++         QQmlJSAnnotation qqmljsAnnotation;

++         qqmljsAnnotation.name = buildName(annotation->qualifiedTypeNameId);

++

++         for (UiObjectMemberList *memberItem = annotation->initializer->members; memberItem != nullptr; memberItem = memberItem->next) {

++             switch (memberItem->member->kind) {

++             case Node::Kind_UiScriptBinding: {

++                 auto *scriptBinding = QQmlJS::AST::cast<UiScriptBinding*>(memberItem->member);

++                 qqmljsAnnotation.bindings[buildName(scriptBinding->qualifiedId)]

++                         = bindingToVariant(scriptBinding->statement);

++                 break;

++             }

++             default:

++                 // We ignore all the other information contained in the annotation

++                 break;

++             }

++         }

++

++         annotationList.append(qqmljsAnnotation);

++     }

++

++     return annotationList;

++ }

++

++ void QQmlJSImportVisitor::setAllBindings()

++ {

++     using Key = std::pair<QQmlJSScope::ConstPtr, QString>;

++     QHash<Key, QQmlJS::SourceLocation> foundBindings;

++

++     for (auto it = m_bindings.cbegin(); it != m_bindings.cend(); ++it) {

++         // ensure the scope is resolved. If not, produce a warning.

++         const QQmlJSScope::Ptr type = it->owner;

++         if (!checkTypeResolved(type))

++             continue;

++

++         // create() expects that the types are fully resolved

++         // TODO: Ideally, this extra isFullyResolved shouldn't be needed.

++         //  and should handled inside checkTypeResolved above but that function

++         //  also contains checkCustomParser(type) for whatever reason.

++         // So if a type is not fully resolved but also has a custom parser,

++         // we would still call it->create without types being fully resolved.

++         if (!type->isFullyResolved())

++             continue;

++         auto binding = it->create();

++         if (!binding.isValid())

++             continue;

++         type->addOwnPropertyBinding(binding, it->specifier);

++

++         // we handle interceptors and value sources in processPropertyBindingObjects()

++         if (binding.hasInterceptor() || binding.hasValueSource())

++             continue;

++         const QString propertyName = binding.propertyName();

++         QQmlJSMetaProperty property = type->property(propertyName);

++

++         /* if we can't tell anything about the property, we don't emit warnings:

++            There might be a custom parser, or the type is unresolvable, but it

++            would be a list property – no reason to flood the user with warnings

++            There should be a warning about the property anyway (unless it's from

++            a custom parser).

++         */

++         if (!property.isValid())

++             continue;

++

++         // list can be bound multiple times

++         if (property.isList())

++             continue;

++

++         const Key key = std::make_pair(type, propertyName);

++         auto sourceLocationIt = foundBindings.constFind(key);

++         if (sourceLocationIt == foundBindings.constEnd()) {

++             foundBindings.insert(key, binding.sourceLocation());

++             continue;

++         }

++

++         const QQmlJS::SourceLocation location = binding.sourceLocation();

++         m_logger->log("Duplicate binding on property '%1'"_L1.arg(propertyName),

++                       qmlDuplicatePropertyBinding, location);

++         m_logger->log("Note: previous binding on '%1' here"_L1.arg(propertyName),

++                       qmlDuplicatePropertyBinding, *sourceLocationIt, true, true, {},

++                       location.startLine);

++     }

++ }

++

++ void QQmlJSImportVisitor::processDefaultProperties()

++ {

++     for (auto it = m_pendingDefaultProperties.constBegin();

++          it != m_pendingDefaultProperties.constEnd(); ++it) {

++         QQmlJSScope::ConstPtr parentScope = it.key();

++

++         // We can't expect custom parser default properties to be sensible, discard them for now.

++         if (checkCustomParser(parentScope))

++             continue;

++

++         if (!checkTypeResolved(parentScope))

++             continue;

++

++         /* consider:

++          *

++          *      QtObject { // <- parentScope

++          *          default property var p // (1)

++          *          QtObject {} // (2)

++          *      }

++          *

++          * `p` (1) is a property of a subtype of QtObject, it couldn't be used

++          * in a property binding (2)

++          */

++         // thus, use a base type of parent scope to detect a default property

++         parentScope = parentScope->baseType();

++

++         const QString defaultPropertyName =

++                 parentScope ? parentScope->defaultPropertyName() : QString();

++

++         if (defaultPropertyName.isEmpty()) {

++             // If the parent scope is based on Component it can have any child element

++             // TODO: We should also store these somewhere

++             bool isComponent = false;

++             for (QQmlJSScope::ConstPtr s = parentScope; s; s = s->baseType()) {

++                 if (s->internalName() == QStringLiteral("QQmlComponent")) {

++                     isComponent = true;

++                     break;

++                 }

++             }

++

++             if (!isComponent && checkTypeResolved(parentScope)) {

++                 m_logger->log(QStringLiteral("Cannot assign to non-existent default property"),

++                               qmlMissingProperty, it.value().constFirst()->sourceLocation());

++             }

++

++             continue;

++         }

++

++         const QQmlJSMetaProperty defaultProp = parentScope->property(defaultPropertyName);

++         auto propType = defaultProp.type();

++         const auto handleUnresolvedDefaultProperty = [&](const QQmlJSScope::ConstPtr &) {

++             // Property type is not fully resolved we cannot tell any more than this

++             m_logger->log(QStringLiteral("Property \"%1\" has incomplete type \"%2\". You may be "

++                                          "missing an import.")

++                                   .arg(defaultPropertyName)

++                                   .arg(defaultProp.typeName()),

++                           qmlUnresolvedType, it.value().constFirst()->sourceLocation());

++         };

++

++         const auto assignToUnknownProperty = [&]() {

++             // We don't know the property type. It could be QQmlComponent, which would mean that

++             // IDs from the inner scopes are inaccessible.

++             for (const QQmlJSScope::Ptr &scope : std::as_const(*it))

++                 scope->setAssignedToUnknownProperty(true);

++         };

++

++         if (propType.isNull()) {

++             if (checkTypeResolved(parentScope)

++                 && QQmlJSScope::ownerOfProperty(parentScope, defaultPropertyName).scope->filePath()

++                         != m_exportedRootScope->filePath()) {

++                 handleUnresolvedDefaultProperty(propType);

++             }

++             assignToUnknownProperty();

++             continue;

++         }

++

++         if (it.value().size() > 1

++                 && !defaultProp.isList()

++                 && !propType->isListProperty()) {

++             m_logger->log(

++                     QStringLiteral("Cannot assign multiple objects to a default non-list property"),

++                     qmlNonListProperty, it.value().constFirst()->sourceLocation());

++         }

++

++         if (!checkTypeResolved(propType, handleUnresolvedDefaultProperty)) {

++             assignToUnknownProperty();

++             continue;

++         }

++

++         for (const QQmlJSScope::Ptr &scope : std::as_const(*it)) {

++             if (!checkTypeResolved(scope))

++                 continue;

++

++             // Assigning any element to a QQmlComponent property implicitly wraps it into a Component

++             // Check whether the property can be assigned the scope

++             if (propType->canAssign(scope)) {

++                 scope->setIsWrappedInImplicitComponent(

++                         causesImplicitComponentWrapping(defaultProp, scope));

++                 continue;

++             }

++

++             m_logger->log(QStringLiteral("Cannot assign to default property of incompatible type"),

++                           qmlIncompatibleType, scope->sourceLocation());

++         }

++     }

++ }

++

++ void QQmlJSImportVisitor::processPropertyTypes()

++ {

++     for (const PendingPropertyType &type : std::as_const(m_pendingPropertyTypes)) {

++         Q_ASSERT(type.scope->hasOwnProperty(type.name));

++

++         auto property = type.scope->ownProperty(type.name);

++

++         if (const auto propertyType = QQmlJSScope::findType(

++                 property.typeName(), m_rootScopeImports.contextualTypes()).scope) {

++             property.setType(property.isList() ? propertyType->listType() : propertyType);

++             type.scope->addOwnProperty(property);

++         } else {

++             QString msg = property.typeName() + ' '_L1 + wasNotFound;

++             if (property.typeName() == "list"_L1)

++                 msg += " list is not a type. It requires an element type argument (eg. list<int>)"_L1;

++             m_logger->log(msg, qmlImport, type.location);

++         }

++     }

++ }

++

++ void QQmlJSImportVisitor::processMethodTypes()

++ {

++     const auto isEnumUsedAsType = [&](QStringView typeName, const QQmlJS::SourceLocation &loc) {

++         if (typeName == "enum"_L1) {

++             // note: we already warned about 'enum' in the parser

++             return true;

++         }

++         const auto split = typeName.tokenize(u'.').toContainer<QVarLengthArray<QStringView, 4>>();

++         if (split.size() != 2)

++             return false;

++

++         const QStringView scopeName = split[0];

++         const QStringView enumName = split[1];

++

++         if (auto scope = QQmlJSScope::findType(scopeName.toString(),

++                                                m_rootScopeImports.contextualTypes()).scope) {

++             if (scope->enumeration(enumName.toString()).isValid()) {

++                 m_logger->log(

++                         "QML enumerations are not types. Use int, or use double if the enum's underlying type does not fit into int."_L1,

++                         qmlEnumsAreNotTypes, loc);

++                 return true;

++             }

++         }

++         return false;

++     };

++

++     for (const auto &method : std::as_const(m_pendingMethodTypeAnnotations)) {

++         for (auto [it, end] = method.scope->mutableOwnMethodsRange(method.methodName); it != end; ++it) {

++             const auto [parameterBegin, parameterEnd] = it->mutableParametersRange();

++             for (auto parameter = parameterBegin; parameter != parameterEnd; ++parameter) {

++                 const int parameterIndex = parameter - parameterBegin;

++                 if (isEnumUsedAsType(parameter->typeName(), method.locations[parameterIndex]))

++                     continue;

++                 if (const auto parameterType = QQmlJSScope::findType(

++                             parameter->typeName(), m_rootScopeImports.contextualTypes()).scope) {

++                     parameter->setType({ parameterType });

++                 } else {

++                     m_logger->log(

++                             u"\"%1\" was not found for the type of parameter \"%2\" in method \"%3\"."_s

++                                     .arg(parameter->typeName(), parameter->name(), it->methodName()),

++                             qmlUnresolvedType, method.locations[parameter - parameterBegin]);

++                 }

++             }

++

++             if (isEnumUsedAsType(it->returnTypeName(), method.locations.last()))

++                 continue;

++             if (const auto returnType = QQmlJSScope::findType(

++                         it->returnTypeName(), m_rootScopeImports.contextualTypes()).scope) {

++                 it->setReturnType({ returnType });

++             } else {

++                 m_logger->log(u"\"%1\" was not found for the return type of method \"%2\"."_s.arg(

++                                       it->returnTypeName(), it->methodName()),

++                               qmlUnresolvedType, method.locations.last());

++             }

++         }

++     }

++ }

++

++ // TODO: We should investigate whether bindings shouldn't resolve this earlier by themselves

++ /*!

++ \internal

++ Resolves \a possiblyGroupedProperty on a type represented by \a scope.

++ possiblyGroupedProperty can be either a simple name, or a grouped property ("foo.bar.baz")

++ In the latter case, we resolve the "head" to a property, and then continue with the tail on

++ the properties' type.

++ We don't handle ids here

++  */

++ static QQmlJSMetaProperty resolveProperty(const QString &possiblyGroupedProperty, QQmlJSScope::ConstPtr scope)

++ {

++     QQmlJSMetaProperty property;

++     for (QStringView propertyName: possiblyGroupedProperty.tokenize(u".")) {

++         property = scope->property(propertyName.toString());

++         if (property.isValid())

++             scope = property.type();

++         else

++             return property;

++     }

++     return property;

++ }

++

++ void QQmlJSImportVisitor::processPropertyBindingObjects()

++ {

++     QSet<std::pair<QQmlJSScope::Ptr, QString>> foundLiterals;

++     {

++         // Note: populating literals here is special, because we do not store

++         // them in m_pendingPropertyObjectBindings, so we have to lookup all

++         // bindings on a property for each scope and see if there are any

++         // literal bindings there. this is safe to do once at the beginning

++         // because this function doesn't add new literal bindings and all

++         // literal bindings must already be added at this point.

++         QSet<std::pair<QQmlJSScope::Ptr, QString>> visited;

++         for (const PendingPropertyObjectBinding &objectBinding :

++              std::as_const(m_pendingPropertyObjectBindings)) {

++             // unique because it's per-scope and per-property

++             const auto uniqueBindingId = std::make_pair(objectBinding.scope, objectBinding.name);

++             if (visited.contains(uniqueBindingId))

++                 continue;

++             visited.insert(uniqueBindingId);

++

++             auto [existingBindingsBegin, existingBindingsEnd] =

++                     uniqueBindingId.first->ownPropertyBindings(uniqueBindingId.second);

++             const bool hasLiteralBindings =

++                     std::any_of(existingBindingsBegin, existingBindingsEnd,

++                                 [](const QQmlJSMetaPropertyBinding &x) { return x.hasLiteral(); });

++             if (hasLiteralBindings)

++                 foundLiterals.insert(uniqueBindingId);

++         }

++     }

++

++     QSet<std::pair<QQmlJSScope::Ptr, QString>> foundObjects;

++     QSet<std::pair<QQmlJSScope::Ptr, QString>> foundInterceptors;

++     QSet<std::pair<QQmlJSScope::Ptr, QString>> foundValueSources;

++

++     for (const PendingPropertyObjectBinding &objectBinding :

++          std::as_const(m_pendingPropertyObjectBindings)) {

++         const QString propertyName = objectBinding.name;

++         QQmlJSScope::Ptr childScope = objectBinding.childScope;

++

++         const auto assignToUnknownProperty = [&]() {

++             // We don't know the property type. It could be QQmlComponent which would mean

++             // that IDs from the child scope are inaccessible outside of it.

++             childScope->setAssignedToUnknownProperty(true);

++         };

++

++         // guarantees property lookup

++         if (!checkTypeResolved(objectBinding.scope)) {

++             assignToUnknownProperty();

++             continue;

++         }

++

++         QQmlJSMetaProperty property = resolveProperty(propertyName, objectBinding.scope);

++

++         if (!property.isValid()) {

++             warnMissingPropertyForBinding(propertyName, objectBinding.location);

++             continue;

++         }

++         const auto handleUnresolvedProperty = [&](const QQmlJSScope::ConstPtr &) {

++             // Property type is not fully resolved we cannot tell any more than this

++             m_logger->log(QStringLiteral("Property \"%1\" has incomplete type \"%2\". You may be "

++                                          "missing an import.")

++                                   .arg(propertyName)

++                                   .arg(property.typeName()),

++                           qmlUnresolvedType, objectBinding.location);

++         };

++

++         if (property.type().isNull()) {

++             assignToUnknownProperty();

++             if (checkTypeResolved(objectBinding.scope)

++                 && QQmlJSScope::ownerOfProperty(objectBinding.scope, propertyName).scope->filePath()

++                         != m_exportedRootScope->filePath()) {

++                 // If this property was defined in the same QML document then we already warned about it

++                 // somewhere.

++                 handleUnresolvedProperty(property.type());

++             }

++             continue;

++         }

++

++         // guarantee that canAssign() can be called

++         if (!checkTypeResolved(property.type(), handleUnresolvedProperty)) {

++             assignToUnknownProperty();

++             continue;

++         } else if (!checkTypeResolved(childScope)) {

++             continue;

++         }

++

++         if (!objectBinding.onToken && !property.type()->canAssign(childScope)) {

++             m_logger->log(QStringLiteral("Cannot assign object of type %1 to %2")

++                                   .arg(QQmlJSUtils::getScopeName(childScope, QQmlSA::ScopeType::QMLScope))

++                                   .arg(property.typeName()),

++                           qmlIncompatibleType, childScope->sourceLocation());

++             continue;

++         }

++

++         childScope->setIsWrappedInImplicitComponent(

++                 causesImplicitComponentWrapping(property, childScope));

++

++         // unique because it's per-scope and per-property

++         const auto uniqueBindingId = std::make_pair(objectBinding.scope, objectBinding.name);

++         const QString typeName = QQmlJSUtils::getScopeName(childScope, QQmlSA::ScopeType::QMLScope);

++

++         auto isConditionalBinding = [&]() -> bool {

++             /* this is a heuristic; we don't want to warn about multiple

++                mutually exclusive bindings, even if they target the same

++                property. We don't have a proper way to detect this, so

++                we check for the presence of some bindings as a hint

++             */

++             return childScope->hasOwnPropertyBindings(u"enabled"_s)

++                     || childScope->hasOwnPropertyBindings(u"when"_s)

++                     || childScope->hasOwnPropertyBindings(u"running"_s);

++         };

++

++         if (objectBinding.onToken) {

++             if (childScope->hasInterface(QStringLiteral("QQmlPropertyValueInterceptor"))) {

++                 if (foundInterceptors.contains(uniqueBindingId)) {

++                     if (!isConditionalBinding()) {

++                         m_logger->log(QStringLiteral("Duplicate interceptor on property \"%1\"")

++                                           .arg(propertyName),

++                                   qmlDuplicatePropertyBinding, objectBinding.location);

++                     }

++                 } else {

++                     foundInterceptors.insert(uniqueBindingId);

++                 }

++             } else if (childScope->hasInterface(QStringLiteral("QQmlPropertyValueSource"))) {

++                 if (foundValueSources.contains(uniqueBindingId)) {

++                     if (!isConditionalBinding()) {

++                         m_logger->log(QStringLiteral("Duplicate value source on property \"%1\"")

++                                           .arg(propertyName),

++                                   qmlDuplicatePropertyBinding, objectBinding.location);

++                     }

++                 } else if (foundObjects.contains(uniqueBindingId)

++                            || foundLiterals.contains(uniqueBindingId)) {

++                     if (!isConditionalBinding())  {

++                         m_logger->log(QStringLiteral("Cannot combine value source and binding on "

++                                                  "property \"%1\"")

++                                           .arg(propertyName),

++                                   qmlDuplicatePropertyBinding, objectBinding.location);

++                     }

++                 } else {

++                     foundValueSources.insert(uniqueBindingId);

++                 }

++             } else {

++                 m_logger->log(QStringLiteral("On-binding for property \"%1\" has wrong type \"%2\"")

++                                       .arg(propertyName)

++                                       .arg(typeName),

++                               qmlIncompatibleType, objectBinding.location);

++             }

++         } else {

++             if (foundValueSources.contains(uniqueBindingId)) {

++                 if (!isConditionalBinding())  {

++                     m_logger->log(

++                         QStringLiteral("Cannot combine value source and binding on property \"%1\"")

++                                 .arg(propertyName),

++                         qmlDuplicatePropertyBinding, objectBinding.location);

++                 }

++             } else {

++                 foundObjects.insert(uniqueBindingId);

++             }

++         }

++     }

++ }

++

++ static QList<QQmlJSScope::ConstPtr> qmlScopeDescendants(const QQmlJSScope::ConstPtr &scope)

++ {

++     QList<QQmlJSScope::ConstPtr> descendants;

++     std::vector<QQmlJSScope::ConstPtr> toVisit;

++

++     toVisit.push_back(scope);

++     while (!toVisit.empty()) {

++         const QQmlJSScope::ConstPtr s = toVisit.back();

++         toVisit.pop_back();

++         if (s->scopeType() == QQmlSA::ScopeType::QMLScope) {

++             if (s != scope)

++                 descendants << s;

++

++             toVisit.insert(toVisit.end(), s->childScopesBegin(), s->childScopesEnd());

++         }

++     }

++

++     return descendants;

++ }

++

++ void QQmlJSImportVisitor::populatePropertyAliases()

++ {

++     for (const auto &alias : std::as_const(m_aliasDefinitions)) {

++         const auto &[aliasScope, aliasName] = alias;

++         if (aliasScope.isNull())

++             continue;

++

++         auto property = aliasScope->ownProperty(aliasName);

++         if (!property.isValid() || !property.aliasTargetScope())

++             continue;

++

++         Property target(property.aliasTargetScope(), property.aliasTargetName());

++

++         do {

++             m_propertyAliases[target].append(alias);

++             property = target.scope->property(target.name);

++             target = Property(property.aliasTargetScope(), property.aliasTargetName());

++         } while (property.isAlias() && target.scope);

++     }

++ }

++

++ void QQmlJSImportVisitor::checkRequiredProperties()

++ {

++     for (const auto &required : std::as_const(m_requiredProperties)) {

++         if (!required.scope->hasProperty(required.name)) {

++             m_logger->log(

++                     QStringLiteral("Property \"%1\" was marked as required but does not exist.")

++                             .arg(required.name),

++                     qmlRequired, required.location);

++         }

++     }

++

++     const auto compType = m_rootScopeImports.type(u"Component"_s).scope;

++     const auto isComponentRoot = [&](const QQmlJSScope::ConstPtr &requiredScope) {

++         if (requiredScope->isWrappedInImplicitComponent())

++             return true;

++         if (const auto s = requiredScope->parentScope(); s &&  s->baseType() == compType)

++             return true;

++         return false;

++     };

++

++     const auto scopeRequiresProperty = [&](const QQmlJSScope::ConstPtr &requiredScope,

++                                            const QString &propName,

++                                            const QQmlJSScope::ConstPtr &descendant) {

++         if (!requiredScope->isPropertyLocallyRequired(propName))

++             return false;

++

++         // check if property owners are the same: the owners can be different in case of shadowing.

++         return QQmlJSScope::ownerOfProperty(requiredScope, propName).scope

++                 == QQmlJSScope::ownerOfProperty(descendant, propName).scope;

++     };

++

++     const auto requiredHasBinding = [](const QList<QQmlJSScope::ConstPtr> &scopesToSearch,

++                                        const QQmlJSScope::ConstPtr &owner,

++                                        const QString &propName) {

++         for (const auto &scope : scopesToSearch) {

++             if (scope->property(propName).isAlias())

++                 continue;

++             const auto &[begin, end] = scope->ownPropertyBindings(propName);

++             for (auto it = begin; it != end; ++it) {

++                 // attached and grouped bindings should not be considered here

++                 const bool isRelevantBinding = QQmlSA::isRegularBindingType(it->bindingType())

++                         || it->bindingType() == QQmlSA::BindingType::Interceptor

++                         || it->bindingType() == QQmlSA::BindingType::ValueSource;

++                 if (!isRelevantBinding)

++                     continue;

++                 if (QQmlJSScope::ownerOfProperty(scope, propName).scope == owner)

++                     return true;

++             }

++         }

++

++         return false;

++     };

++

++     const auto requiredUsedInRootAlias = [&](const QQmlJSScope::ConstPtr &requiredScope,

++                                              const QString &propName) {

++         const Property target(requiredScope, propName);

++         // m_propertyAliases contains all aliases that points to target, either directly or

++         // indirectly.

++         const auto allAliasesToTargetIt = m_propertyAliases.constFind(target);

++         if (allAliasesToTargetIt == m_propertyAliases.constEnd())

++             return false;

++

++         // If one alias is in the file root component, than the required property can be fulfilled

++         // by the alias when it is instantiated, and we shouldn't warn in the current QML component

++         // about the unsatisfied required property.

++         return std::any_of(

++                 allAliasesToTargetIt->constBegin(), allAliasesToTargetIt->constEnd(),

++                 [](const Property &property) { return property.scope->isFileRootComponent(); });

++     };

++

++     const auto requiredSetThroughAlias = [&](const QList<QQmlJSScope::ConstPtr> &scopesToSearch,

++                                              const QQmlJSScope::ConstPtr &requiredScope,

++                                              const QString &propName) {

++         const auto &propertyDefScope = QQmlJSScope::ownerOfProperty(requiredScope, propName);

++         const auto &propertyAliases = m_propertyAliases[{ propertyDefScope.scope, propName }];

++         for (const auto &alias : propertyAliases) {

++             for (const auto &s : scopesToSearch) {

++                 if (s->hasOwnPropertyBindings(alias.name))

++                     return true;

++             }

++         }

++         return false;

++     };

++

++     const auto warn = [this](const QQmlJSScope::ConstPtr &prevRequiredScope,

++                              const QString &propName, const QQmlJSScope::ConstPtr &defScope,

++                              const QQmlJSScope::ConstPtr &requiredScope,

++                              const QQmlJSScope::ConstPtr &descendant) {

++         const auto &propertyScope = QQmlJSScope::ownerOfProperty(requiredScope, propName).scope;

++         const QString propertyScopeName = !propertyScope.isNull()

++                 ? QQmlJSUtils::getScopeName(propertyScope, QQmlSA::ScopeType::QMLScope)

++                 : u"here"_s;

++

++         std::optional<QQmlJSFixSuggestion> suggestion;

++

++         QString message = QStringLiteral("Component is missing required property %1 from %2")

++                                   .arg(propName)

++                                   .arg(propertyScopeName);

++         if (requiredScope != descendant) {

++             const QString requiredScopeName = prevRequiredScope

++                     ? QQmlJSUtils::getScopeName(prevRequiredScope, QQmlSA::ScopeType::QMLScope)

++                     : u"here"_s;

++

++             if (!prevRequiredScope.isNull()) {

++                 if (auto sourceScope = prevRequiredScope->baseType()) {

++                     suggestion = QQmlJSFixSuggestion{

++                         "%1:%2:%3: Property marked as required in %4."_L1

++                                 .arg(sourceScope->filePath())

++                                 .arg(sourceScope->sourceLocation().startLine)

++                                 .arg(sourceScope->sourceLocation().startColumn)

++                                 .arg(requiredScopeName),

++                         sourceScope->sourceLocation()

++                     };

++                     // note: suggestions only accepts qml file paths, and can't open the

++                     // non-absolute paths in QQmlJSScope::filePath of C++ defined types

++                     if (sourceScope->isComposite())

++                         suggestion->setFilename(sourceScope->filePath());

++                 }

++             } else {

++                 message += " (marked as required by %1)"_L1.arg(requiredScopeName);

++             }

++         }

++

++         m_logger->log(message, qmlRequired, defScope->sourceLocation(), true, true, suggestion);

++     };

++

++     populatePropertyAliases();

++

++     for (const auto &[_, defScope] : m_scopesByIrLocation.asKeyValueRange()) {

++         if (defScope->isFileRootComponent() || defScope->isInlineComponent()

++                 || defScope->componentRootStatus() != QQmlJSScope::IsComponentRoot::No

++             || defScope->scopeType() != QQmlSA::ScopeType::QMLScope) {

++             continue;

++         }

++

++         QList<QQmlJSScope::ConstPtr> scopesToSearch;

++         for (QQmlJSScope::ConstPtr scope = defScope; scope; scope = scope->baseType()) {

++             const auto descendants = QList<QQmlJSScope::ConstPtr>()

++                     << scope << qmlScopeDescendants(scope);

++             for (const QQmlJSScope::ConstPtr &descendant : std::as_const(descendants)) {

++                 // Ignore inline components of children. Base types need to be always checked for

++                 // required properties, even if they are defined in an inline component.

++                 if (descendant != scope && descendant->isInlineComponent())

++                     continue;

++                 scopesToSearch << descendant;

++                 const auto ownProperties = descendant->ownProperties();

++                 for (auto propertyIt = ownProperties.constBegin();

++                      propertyIt != ownProperties.constEnd(); ++propertyIt) {

++                     const QString propName = propertyIt.key();

++                     if (descendant->hasOwnPropertyBindings(propName))

++                         continue;

++

++                     QQmlJSScope::ConstPtr prevRequiredScope;

++                     for (const QQmlJSScope::ConstPtr &requiredScope : std::as_const(scopesToSearch)) {

++                         // Stop at component boundaries. We don't want to report the same problem

++                         // multiple times.

++                         if (isComponentRoot(requiredScope))

++                             break;

++

++                         if (!scopeRequiresProperty(requiredScope, propName, descendant)) {

++                             prevRequiredScope = requiredScope;

++                             continue;

++                         }

++

++                         if (requiredHasBinding(scopesToSearch, descendant, propName))

++                             continue;

++

++                         if (requiredUsedInRootAlias(requiredScope, propName))

++                             continue;

++

++                         if (requiredSetThroughAlias(scopesToSearch, requiredScope, propName))

++                             continue;

++

++                         warn(prevRequiredScope, propName, defScope, requiredScope, descendant);

++                         prevRequiredScope = requiredScope;

++                     }

++                 }

++             }

++         }

++     }

++ }

++

++ void QQmlJSImportVisitor::processPropertyBindings()

++ {

++     for (auto it = m_propertyBindings.constBegin(); it != m_propertyBindings.constEnd(); ++it) {

++         QQmlJSScope::Ptr scope = it.key();

++         for (auto &[visibilityScope, location, name] : it.value()) {

++             if (!scope->hasProperty(name) && !m_logger->isDisabled()) {

++                 // These warnings do not apply for custom parsers and their children and need to be

++                 // handled on a case by case basis

++

++                 if (checkCustomParser(scope))

++                     continue;

++

++                 // TODO: Can this be in a better suited category?

++                 std::optional<QQmlJSFixSuggestion> fixSuggestion;

++

++                 for (QQmlJSScope::ConstPtr baseScope = scope; !baseScope.isNull();

++                      baseScope = baseScope->baseType()) {

++                     if (auto suggestion = QQmlJSUtils::didYouMean(

++                                 name, baseScope->ownProperties().keys(), m_logger->filePath(), location);

++                         suggestion.has_value()) {

++                         fixSuggestion = suggestion;

++                         break;

++                     }

++                 }

++

++                 if (checkTypeResolved(scope))

++                     warnMissingPropertyForBinding(name, location, fixSuggestion);

++                 continue;

++             }

++

++             const auto property = scope->property(name);

++             if (!property.type()) {

++                 m_logger->log(QStringLiteral("No type found for property \"%1\". This may be due "

++                                              "to a missing import statement or incomplete "

++                                              "qmltypes files.")

++                                       .arg(name),

++                               qmlMissingType, location);

++             }

++

++             const auto &annotations = property.annotations();

++

++             const auto deprecationAnn =

++                     std::find_if(annotations.cbegin(), annotations.cend(),

++                                  [](const QQmlJSAnnotation &ann) { return ann.isDeprecation(); });

++

++             if (deprecationAnn != annotations.cend()) {

++                 const auto deprecation = deprecationAnn->deprecation();

++

++                 QString message = QStringLiteral("Binding on deprecated property \"%1\"")

++                                           .arg(property.propertyName());

++

++                 if (!deprecation.reason.isEmpty())

++                     message.append(QStringLiteral(" (Reason: %1)").arg(deprecation.reason));

++

++                 m_logger->log(message, qmlDeprecated, location);

++             }

++         }

++     }

++ }

++

++ void QQmlJSImportVisitor::checkSignal(

++         const QQmlJSScope::ConstPtr &signalScope, const QQmlJS::SourceLocation &location,

++         const QString &handlerName, const QStringList &handlerParameters)

++ {

++     const auto signal = QQmlSignalNames::handlerNameToSignalName(handlerName);

++

++     std::optional<QQmlJSMetaMethod> signalMethod;

++     const auto setSignalMethod = [&](const QQmlJSScope::ConstPtr &scope, const QString &name) {

++         const auto methods = scope->methods(name, QQmlJSMetaMethodType::Signal);

++         if (!methods.isEmpty())

++             signalMethod = methods[0];

++     };

++

++     if (signal.has_value()) {

++         if (signalScope->hasMethod(*signal)) {

++             setSignalMethod(signalScope, *signal);

++         } else if (auto p = QQmlJSUtils::propertyFromChangedHandler(signalScope, handlerName)) {

++             // we have a change handler of the form "onXChanged" where 'X'

++             // is a property name

++

++             // NB: qqmltypecompiler prefers signal to bindable

++             if (auto notify = p->notify(); !notify.isEmpty()) {

++                 setSignalMethod(signalScope, notify);

++             } else {

++                 Q_ASSERT(!p->bindable().isEmpty());

++                 signalMethod = QQmlJSMetaMethod {}; // use dummy in this case

++             }

++         }

++     }

++

++     if (!signalMethod.has_value()) { // haven't found anything

++         // TODO: This should move  into a new "Qml (module) Lint Plugin"

++         // There is a small chance of suggesting this fix for things that are not actually

++         // QtQml/Connections elements, but rather some other thing that is also called

++         // "Connections". However, I guess we can live with this.

++         if (signalScope->baseTypeName() == QStringLiteral("Connections")) {

++             m_logger->log(

++                     u"Implicitly defining \"%1\" as signal handler in Connections is deprecated. "

++                     u"Create a function instead: \"function %2(%3) { ... }\"."_s.arg(

++                             handlerName, handlerName, handlerParameters.join(u", ")),

++                     qmlUnqualified, location, true, true);

++             return;

++         }

++

++         auto baseType = QQmlJSScope::nonCompositeBaseType(signalScope);

++         if (baseType && baseType->hasCustomParser())

++             return; // we can't know what custom parser actually supports

++

++         m_logger->log(

++                 QStringLiteral("no matching signal found for handler \"%1\"").arg(handlerName),

++                 qmlUnqualified, location, true, true);

++         return;

++     }

++

++     const auto signalParameters = signalMethod->parameters();

++     QHash<QString, qsizetype> parameterNameIndexes;

++     // check parameter positions and also if signal is suitable for onSignal handler

++     for (int i = 0, end = signalParameters.size(); i < end; i++) {

++         auto &p = signalParameters[i];

++         parameterNameIndexes[p.name()] = i;

++

++         auto signalName = [&]() {

++             if (signal)

++                 return u" called %1"_s.arg(*signal);

++             return QString();

++         };

++         auto type = p.type();

++         if (!type) {

++             m_logger->log(

++                     "Type %1 of parameter %2 in signal%3 was not found, but is required to compile "

++                     "%4."_L1.arg(p.typeName(), p.name(), signalName(), handlerName),

++                     qmlSignalParameters, location);

++             continue;

++         }

++

++         if (type->isComposite())

++             continue;

++

++         // only accept following parameters for non-composite types:

++         // * QObjects by pointer (nonconst*, const*, const*const,*const)

++         // * Value types by value (QFont, int)

++         // * Value types by const ref (const QFont&, const int&)

++

++         auto parameterName = [&]() {

++             if (p.name().isEmpty())

++                 return QString();

++             return u" called %1"_s.arg(p.name());

++         };

++         switch (type->accessSemantics()) {

++         case QQmlJSScope::AccessSemantics::Reference:

++             if (!p.isPointer())

++                 m_logger->log(QStringLiteral("Type %1 of parameter%2 in signal%3 should be "

++                                              "passed by pointer to be able to compile %4. ")

++                                       .arg(p.typeName(), parameterName(), signalName(),

++                                            handlerName),

++                               qmlSignalParameters, location);

++             break;

++         case QQmlJSScope::AccessSemantics::Value:

++         case QQmlJSScope::AccessSemantics::Sequence:

++             if (p.isPointer())

++                 m_logger->log(

++                         QStringLiteral(

++                                 "Type %1 of parameter%2 in signal%3 should be passed by "

++                                 "value or const reference to be able to compile %4. ")

++                                 .arg(p.typeName(), parameterName(), signalName(),

++                                      handlerName),

++                         qmlSignalParameters, location);

++             break;

++         case QQmlJSScope::AccessSemantics::None:

++             m_logger->log(

++                     QStringLiteral("Type %1 of parameter%2 in signal%3 required by the "

++                                    "compilation of %4 cannot be used. ")

++                             .arg(p.typeName(), parameterName(), signalName(), handlerName),

++                     qmlSignalParameters, location);

++             break;

++         }

++     }

++

++     if (handlerParameters.size() > signalParameters.size()) {

++         m_logger->log(QStringLiteral("Signal handler for \"%2\" has more formal"

++                                      " parameters than the signal it handles.")

++                               .arg(handlerName),

++                       qmlSignalParameters, location);

++         return;

++     }

++

++     for (qsizetype i = 0, end = handlerParameters.size(); i < end; i++) {

++         const QStringView handlerParameter = handlerParameters.at(i);

++         auto it = parameterNameIndexes.constFind(handlerParameter.toString());

++         if (it == parameterNameIndexes.constEnd())

++             continue;

++         const qsizetype j = *it;

++

++         if (j == i)

++             continue;

++

++         m_logger->log(QStringLiteral("Parameter %1 to signal handler for \"%2\""

++                                      " is called \"%3\". The signal has a parameter"

++                                      " of the same name in position %4.")

++                               .arg(i + 1)

++                               .arg(handlerName, handlerParameter)

++                               .arg(j + 1),

++                       qmlSignalParameters, location);

++     }

++ }

++

++ void QQmlJSImportVisitor::addDefaultProperties()

++ {

++     QQmlJSScope::ConstPtr parentScope = m_currentScope->parentScope();

++     if (m_currentScope == m_exportedRootScope || parentScope->isArrayScope()

++         || m_currentScope->isInlineComponent()) // inapplicable

++         return;

++

++     m_pendingDefaultProperties[m_currentScope->parentScope()] << m_currentScope;

++

++     if (checkCustomParser(parentScope))

++         return;

++

++     /* consider:

++      *

++      *      QtObject { // <- parentScope

++      *          default property var p // (1)

++      *          QtObject {} // (2)

++      *      }

++      *

++      * `p` (1) is a property of a subtype of QtObject, it couldn't be used

++      * in a property binding (2)

++      */

++     // thus, use a base type of parent scope to detect a default property

++     parentScope = parentScope->baseType();

++

++     const QString defaultPropertyName =

++             parentScope ? parentScope->defaultPropertyName() : QString();

++

++     if (defaultPropertyName.isEmpty()) // an error somewhere else

++         return;

++

++     // Note: in this specific code path, binding on default property

++     // means an object binding (we work with pending objects here)

++     QQmlJSMetaPropertyBinding binding(m_currentScope->sourceLocation(), defaultPropertyName);

++     binding.setObject(QQmlJSUtils::getScopeName(m_currentScope, QQmlSA::ScopeType::QMLScope),

++                       QQmlJSScope::ConstPtr(m_currentScope));

++     m_bindings.append(UnfinishedBinding { m_currentScope->parentScope(), [=]() { return binding; },

++                                           QQmlJSScope::UnnamedPropertyTarget });

++ }

++

++ void QQmlJSImportVisitor::breakInheritanceCycles(const QQmlJSScope::Ptr &originalScope)

++ {

++     QList<QQmlJSScope::ConstPtr> scopes;

++     for (QQmlJSScope::ConstPtr scope = originalScope; scope;) {

++         if (scopes.contains(scope)) {

++             QString inheritenceCycle;

++             for (const auto &seen : std::as_const(scopes)) {

++                 inheritenceCycle.append(seen->baseTypeName());

++                 inheritenceCycle.append(QLatin1String(" -> "));

++             }

++             inheritenceCycle.append(scopes.first()->baseTypeName());

++

++             const QString message = QStringLiteral("%1 is part of an inheritance cycle: %2")

++                                             .arg(originalScope->baseTypeName(), inheritenceCycle);

++             m_logger->log(message, qmlInheritanceCycle, scope->sourceLocation());

++             originalScope->clearBaseType();

++             originalScope->setBaseTypeError(message);

++             break;

++         }

++

++         scopes.append(scope);

++

++         const auto newScope = scope->baseType();

++         if (newScope.isNull()) {

++             const QString error = scope->baseTypeError();

++             const QString name = scope->baseTypeName();

++             if (!error.isEmpty()) {

++                 m_logger->log(error, qmlImport, scope->sourceLocation(), true, true);

++             } else if (!name.isEmpty() && !m_unresolvedTypes.hasSeen(scope)

++                        && !m_logger->isDisabled()) {

++                 m_logger->log(name + ' '_L1 + wasNotFound + ' '_L1, qmlImport,

++                               scope->sourceLocation(), true, true,

++                               QQmlJSUtils::didYouMean(

++                                       scope->baseTypeName(), m_rootScopeImports.types().keys(),

++                                       m_logger->filePath(), scope->sourceLocation()));

++             }

++         }

++

++         scope = newScope;

++     }

++ }

++

++ void QQmlJSImportVisitor::checkDeprecation(const QQmlJSScope::ConstPtr &originalScope)

++ {

++     for (QQmlJSScope::ConstPtr scope = originalScope; scope; scope = scope->baseType()) {

++         for (const QQmlJSAnnotation &annotation : scope->annotations()) {

++             if (annotation.isDeprecation()) {

++                 QQQmlJSDeprecation deprecation = annotation.deprecation();

++

++                 QString message =

++                         QStringLiteral("Type \"%1\" is deprecated").arg(scope->internalName());

++

++                 if (!deprecation.reason.isEmpty())

++                     message.append(QStringLiteral(" (Reason: %1)").arg(deprecation.reason));

++

++                 m_logger->log(message, qmlDeprecated, originalScope->sourceLocation());

++             }

++         }

++     }

++ }

++

++ void QQmlJSImportVisitor::checkForComponentTypeWithProperties(const QQmlJSScope::ConstPtr &scope)

++ {

++     const QQmlJSScope::ConstPtr base = scope->baseType();

++     if (!base)

++         return;

++

++     // If the base type is composite itself, we ignore it being a QQmlCompoonent and

++     // assume you actually mean its contents (and produce a deprecation warning).

++     // We can ignore this case here.

++     if (base->isComposite())

++         return;

++

++     if (base->internalName() != "QQmlComponent"_L1)

++         return;

++

++     const auto ownProperties = scope->ownProperties();

++     for (const auto &property : ownProperties) {

++         m_logger->log("Component objects cannot declare new properties."_L1,

++                       qmlSyntax, property.sourceLocation());

++     }

++ }

++

++ bool QQmlJSImportVisitor::checkCustomParser(const QQmlJSScope::ConstPtr &scope)

++ {

++     return scope->isInCustomParserParent();

++ }

++

++ void QQmlJSImportVisitor::flushPendingSignalParameters()

++ {

++     const QQmlJSMetaSignalHandler handler = m_signalHandlers[m_pendingSignalHandler];

++     for (const QString &parameter : handler.signalParameters) {

++         safeInsertJSIdentifier(m_currentScope, parameter,

++                                { QQmlJSScope::JavaScriptIdentifier::Injected,

++                                  m_pendingSignalHandler, std::nullopt, false });

++     }

++     m_pendingSignalHandler = QQmlJS::SourceLocation();

++ }

++

++ /*! \internal

++

++     Records a JS function or a Script binding for a given \a scope. Returns an

++     index of a just recorded function-or-expression.

++

++     \sa synthesizeCompilationUnitRuntimeFunctionIndices

++ */

++ QQmlJSMetaMethod::RelativeFunctionIndex

++ QQmlJSImportVisitor::addFunctionOrExpression(const QQmlJSScope::ConstPtr &scope,

++                                              const QString &name)

++ {

++     auto &array = m_functionsAndExpressions[scope];

++     array.emplaceBack(name);

++

++     // add current function to all preceding functions in the stack. we don't

++     // know which one is going to be the "publicly visible" one, so just blindly

++     // add it to every level and let further logic take care of that. this

++     // matches what m_innerFunctions represents as function at each level just

++     // got a new inner function

++     for (const auto &function : std::as_const(m_functionStack))

++         m_innerFunctions[function]++;

++     m_functionStack.push({ scope, name }); // create new function

++

++     return QQmlJSMetaMethod::RelativeFunctionIndex { int(array.size() - 1) };

++ }

++

++ /*! \internal

++

++     Removes last FunctionOrExpressionIdentifier from m_functionStack, performing

++     some checks on \a name.

++

++     \note \a name must match the name added via addFunctionOrExpression().

++

++     \sa addFunctionOrExpression, synthesizeCompilationUnitRuntimeFunctionIndices

++ */

++ void QQmlJSImportVisitor::forgetFunctionExpression(const QString &name)

++ {

++     auto nameToVerify = name.isEmpty() ? u"<anon>"_s : name;

++     Q_UNUSED(nameToVerify);

++     Q_ASSERT(!m_functionStack.isEmpty());

++     Q_ASSERT(m_functionStack.top().name == nameToVerify);

++     m_functionStack.pop();

++ }

++

++ /*! \internal

++

++     Sets absolute runtime function indices for \a scope based on \a count

++     (document-level variable). Returns count incremented by the number of

++     runtime functions that the current \a scope has.

++

++     \note Not all scopes are considered as the function is compatible with the

++     compilation unit output. The runtime functions are only recorded for

++     QmlIR::Object (even if they don't strictly belong to it). Thus, in

++     QQmlJSScope terms, we are only interested in QML scopes, group and attached

++     property scopes.

++ */

++ int QQmlJSImportVisitor::synthesizeCompilationUnitRuntimeFunctionIndices(

++         const QQmlJSScope::Ptr &scope, int count) const

++ {

++     const auto suitableScope = [](const QQmlJSScope::Ptr &scope) {

++         const auto type = scope->scopeType();

++         return type == QQmlSA::ScopeType::QMLScope

++                 || type == QQmlSA::ScopeType::GroupedPropertyScope

++                 || type == QQmlSA::ScopeType::AttachedPropertyScope;

++     };

++

++     if (!suitableScope(scope))

++         return count;

++

++     auto it = m_functionsAndExpressions.constFind(scope);

++     if (it == m_functionsAndExpressions.cend()) // scope has no runtime functions

++         return count;

++

++     const auto &functionsAndExpressions = *it;

++     for (const QString &functionOrExpression : functionsAndExpressions) {

++         scope->addOwnRuntimeFunctionIndex(

++                 static_cast<QQmlJSMetaMethod::AbsoluteFunctionIndex>(count));

++         ++count;

++

++         // there are special cases: onSignal: function() { doSomethingUsefull }

++         // in which we would register 2 functions in the runtime functions table

++         // for the same expression. even more, we can have named and unnamed

++         // closures inside a function or a script binding e.g.:

++         // ```

++         // function foo() {

++         //  var closure = () => { return 42; }; // this is an inner function

++         //  /* or:

++         //      property = Qt.binding(function() { return anotherProperty; });

++         //   */

++         //  return closure();

++         // }

++         // ```

++         // see Codegen::defineFunction() in qv4codegen.cpp for more details

++         count += m_innerFunctions.value({ scope, functionOrExpression }, 0);

++     }

++

++     return count;

++ }

++

++ void QQmlJSImportVisitor::populateRuntimeFunctionIndicesForDocument() const

++ {

++     int count = 0;

++     const auto synthesize = [&](const QQmlJSScope::Ptr &current) {

++         count = synthesizeCompilationUnitRuntimeFunctionIndices(current, count);

++     };

++     QQmlJSUtils::traverseFollowingQmlIrObjectStructure(m_exportedRootScope, synthesize);

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::ExpressionStatement *ast)

++ {

++     if (m_pendingSignalHandler.isValid()) {

++         enterEnvironment(QQmlSA::ScopeType::SignalHandlerFunctionScope, u"signalhandler"_s,

++                          ast->firstSourceLocation());

++         flushPendingSignalParameters();

++     }

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::ExpressionStatement *)

++ {

++     if (m_currentScope->scopeType() == QQmlSA::ScopeType::SignalHandlerFunctionScope) {

++         leaveEnvironment();

++     }

++ }

++

++ inline QQmlJSImportVisitor::UnfinishedBinding

++ createNonUniqueScopeBinding(QQmlJSScope::Ptr &scope, const QString &name,

++                             const QQmlJS::SourceLocation &srcLocation);

++

++ static void logLowerCaseImport(QStringView superType, QQmlJS::SourceLocation location,

++                                QQmlJSLogger *logger)

++ {

++     QStringView namespaceName{ superType };

++     namespaceName = namespaceName.first(namespaceName.indexOf(u'.'));

++     logger->log(u"Namespace '%1' of '%2' must start with an upper case letter."_s.arg(namespaceName)

++                         .arg(superType),

++                 qmlUncreatableType, location, true, true);

++ }

++

++ bool QQmlJSImportVisitor::visit(UiObjectDefinition *definition)

++ {

++     const QString superType = buildName(definition->qualifiedTypeNameId);

++

++     const bool isRoot = !rootScopeIsValid();

++     Q_ASSERT(!superType.isEmpty());

++

++     // we need to assume that it is a type based on its capitalization. Types defined in inline

++     // components, for example, can have their type definition after their type usages:

++     // Item { property IC myIC; component IC: Item{}; }

++     // A QML type name always starts with an upper case letter; "_" is neither upper- nor

++     // lower-case, so use !isUpper() to also catch names like "_bar".

++     const qsizetype indexOfTypeName = superType.lastIndexOf(u'.');

++     const bool looksLikeGroupedProperty = !superType.front().isUpper();

++

++     if (indexOfTypeName != -1 && looksLikeGroupedProperty) {

++         logLowerCaseImport(superType, definition->qualifiedTypeNameId->identifierToken,

++                            m_logger);

++     }

++

++     if (!looksLikeGroupedProperty) {

++         if (!isRoot) {

++             enterEnvironment(QQmlSA::ScopeType::QMLScope, superType,

++                              definition->firstSourceLocation());

++         } else {

++             enterRootScope(QQmlSA::ScopeType::QMLScope, superType,

++                            definition->firstSourceLocation());

++             m_currentScope->setIsRootFileComponentFlag(true);

++         }

++

++         const QTypeRevision revision = m_currentScope->baseTypeRevision();

++         if (auto base = m_currentScope->baseType(); base) {

++             if (isRoot && base->internalName() == u"QQmlComponent") {

++                 m_logger->log(u"Qml top level type cannot be 'Component'."_s, qmlTopLevelComponent,

++                               definition->qualifiedTypeNameId->identifierToken, true, true);

++             }

++             if (base->isSingleton() && m_currentScope->isComposite()) {

++                 m_logger->log(u"Singleton Type %1 is not creatable."_s.arg(

++                                       m_currentScope->baseTypeName()),

++                               qmlUncreatableType, definition->qualifiedTypeNameId->identifierToken,

++                               true, true);

++

++             } else if (!base->isCreatable()) {

++                 // composite type m_currentScope is allowed to be uncreatable, but it cannot be the base of anything else

++                 m_logger->log(u"Type %1 is not creatable."_s.arg(m_currentScope->baseTypeName()),

++                               qmlUncreatableType, definition->qualifiedTypeNameId->identifierToken,

++                               true, true);

++             }

++         }

++         if (m_nextIsInlineComponent) {

++             Q_ASSERT(std::holds_alternative<InlineComponentNameType>(m_currentRootName));

++             const QString &name = std::get<InlineComponentNameType>(m_currentRootName);

++             m_currentScope->setIsInlineComponent(true);

++             m_currentScope->setInlineComponentName(name);

++             m_currentScope->setOwnModuleName(m_exportedRootScope->moduleName());

++             auto precedence = quint8(QQmlJS::PrecedenceValues::InlineComponent);

++             m_rootScopeImports.setType(name, { m_currentScope, revision, precedence });

++             m_nextIsInlineComponent = false;

++         }

++

++         addDefaultProperties();

++         Q_ASSERT(m_currentScope->scopeType() == QQmlSA::ScopeType::QMLScope);

++         m_qmlTypes.append(m_currentScope);

++

++         m_objectDefinitionScopes << m_currentScope;

++     } else {

++         enterEnvironmentNonUnique(QQmlSA::ScopeType::GroupedPropertyScope, superType,

++                                   definition->firstSourceLocation());

++         m_bindings.append(createNonUniqueScopeBinding(m_currentScope, superType,

++                                                       definition->firstSourceLocation()));

++         QQmlJSScope::resolveTypes(m_currentScope, m_rootScopeImports.contextualTypes(),

++                                   usedTypes());

++     }

++

++     m_currentScope->setAnnotations(parseAnnotations(definition->annotations));

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(UiObjectDefinition *)

++ {

++     QQmlJSScope::resolveTypes(m_currentScope, m_rootScopeImports.contextualTypes(), usedTypes());

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(UiInlineComponent *component)

++ {

++     if (!std::holds_alternative<RootDocumentNameType>(m_currentRootName)) {

++         m_logger->log(u"Nested inline components are not supported"_s, qmlSyntax,

++                       component->firstSourceLocation());

++         return true;

++     }

++

++     const auto it = m_seenInlineComponents.constFind(component->name);

++     if (it != m_seenInlineComponents.cend()) {

++         m_logger->log("Duplicate inline component '%1'"_L1.arg(it.key()),

++                       qmlDuplicateInlineComponent, component->firstSourceLocation());

++         m_logger->log("Note: previous component named '%1' here"_L1.arg(it.key()),

++                       qmlDuplicateInlineComponent, it.value(), true, true, {},

++                       component->firstSourceLocation().startLine);

++     } else {

++         m_seenInlineComponents[component->name] = component->firstSourceLocation();

++     }

++

++     m_nextIsInlineComponent = true;

++     m_currentRootName = component->name.toString();

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(UiInlineComponent *component)

++ {

++     m_currentRootName = RootDocumentNameType();

++     if (m_nextIsInlineComponent) {

++         m_logger->log(u"Inline component declaration must be followed by a typename"_s,

++                       qmlSyntax, component->firstSourceLocation());

++     }

++     m_nextIsInlineComponent = false; // might have missed an inline component if file contains invalid QML

++ }

++

++ bool QQmlJSImportVisitor::visit(UiPublicMember *publicMember)

++ {

++     switch (publicMember->type) {

++     case UiPublicMember::Signal: {

++         const QString signalName = publicMember->name.toString();

++         UiParameterList *param = publicMember->parameters;

++         QQmlJSMetaMethod method;

++         method.setMethodType(QQmlJSMetaMethodType::Signal);

++         method.setReturnTypeName(QStringLiteral("void"));

++         method.setMethodName(signalName);

++         method.setSourceLocation(combine(publicMember->firstSourceLocation(),

++                                          publicMember->lastSourceLocation()));

++         method.setMethodIndex(

++                 QQmlJSMetaMethod::RelativeFunctionIndex(m_currentScope->ownMethods().size()));

++         while (param) {

++             method.addParameter(

++                     QQmlJSMetaParameter(

++                             param->name.toString(),

++                             param->type ? param->type->toString() : QString()

++                         ));

++             param = param->next;

++         }

++         m_currentScope->addOwnMethod(method);

++         break;

++     }

++     case UiPublicMember::Property: {

++         const QString propertyName = publicMember->name.toString();

++         QString typeName = buildName(publicMember->memberType);

++         if (typeName.contains(u'.') && typeName.front().isLower()) {

++             logLowerCaseImport(typeName, publicMember->typeToken, m_logger);

++         }

++

++         QString aliasExpr;

++         const bool isAlias = (typeName == u"alias"_s);

++         if (isAlias) {

++             auto tryParseAlias = [&]() {

++             typeName.clear(); // type name is useless for alias here, so keep it empty

++             if (!publicMember->statement) {

++                 m_logger->log(QStringLiteral("Invalid alias expression - an initializer is needed."),

++                               qmlSyntax, publicMember->memberType->firstSourceLocation()); // TODO: extend warning to cover until endSourceLocation

++                 return;

++             }

++             const auto expression = cast<ExpressionStatement *>(publicMember->statement);

++             auto node = expression ? expression->expression : nullptr;

++             auto fex = cast<FieldMemberExpression *>(node);

++             while (fex) {

++                 node = fex->base;

++                 aliasExpr.prepend(u'.' + fex->name.toString());

++                 fex = cast<FieldMemberExpression *>(node);

++             }

++

++             if (const auto idExpression = cast<IdentifierExpression *>(node)) {

++                 aliasExpr.prepend(idExpression->name.toString());

++             } else {

++                 // cast to expression might have failed above, so use publicMember->statement

++                 // to obtain the source location

++                 m_logger->log(QStringLiteral("Invalid alias expression. Only IDs and field "

++                                              "member expressions can be aliased."),

++                               qmlSyntax, publicMember->statement->firstSourceLocation());

++             }

++             };

++             tryParseAlias();

++         }

++         QQmlJSMetaProperty prop;

++         prop.setPropertyName(propertyName);

++         prop.setIsList(publicMember->typeModifier == QLatin1String("list"));

++         prop.setIsWritable(!publicMember->isReadonly());

++         prop.setIsFinal(publicMember->isFinal());

++         prop.setIsVirtual(publicMember->isVirtual());

++         prop.setIsOverride(publicMember->isOverride());

++         prop.setAliasExpression(aliasExpr);

++         prop.setSourceLocation(

++                 combine(publicMember->firstSourceLocation(), publicMember->colonToken));

++         const auto type =

++                 isAlias ? QQmlJSScope::ConstPtr() : m_rootScopeImports.type(typeName).scope;

++         if (type) {

++             const auto factory = type.factory();

++             // note: the type of prop is set via QQmlJSImportVisitor::processPropertyTypes() for lists of lazy types

++             prop.setType(prop.isList() ? (factory ? QQmlJSScope::Ptr{ } : type->listType()) : type);

++             const QString internalName = factory ? factory->internalName() : type->internalName();

++             prop.setTypeName(internalName.isEmpty() ? typeName : internalName);

++

++             // Note: qml supports cyclic dependencies on properties, so don't lazy-load `type` here!

++             // If `type` is lazy-loaded here and uses the currently-linted type, then `type` will only

++             // see the incomplete definition of the currently-linted type and will complain about

++             // missing properties for example.

++             Q_ASSERT(type.factory() == factory);

++         } else if (!isAlias) {

++             m_pendingPropertyTypes << PendingPropertyType { m_currentScope, prop.propertyName(),

++                                                             publicMember->firstSourceLocation() };

++             prop.setTypeName(typeName);

++         }

++         prop.setAnnotations(parseAnnotations(publicMember->annotations));

++         if (publicMember->isDefaultMember())

++             m_currentScope->setOwnDefaultPropertyName(propertyName);

++         prop.setIndex(m_currentScope->ownProperties().size());

++         m_currentScope->addOwnProperty(prop);

++

++         QQmlJSMetaMethod method(

++                 QQmlSignalNames::propertyNameToChangedSignalName(propertyName), u"void"_s);

++         method.setMethodType(QQmlJSMetaMethodType::Signal);

++         method.setIsImplicitQmlPropertyChangeSignal(true);

++         method.setMethodIndex(

++                 QQmlJSMetaMethod::RelativeFunctionIndex(m_currentScope->ownMethods().size()));

++         m_currentScope->addOwnMethod(method);

++

++         if (publicMember->isRequired())

++             m_currentScope->setPropertyLocallyRequired(prop.propertyName(), true);

++

++         BindingExpressionParseResult parseResult = BindingExpressionParseResult::Invalid;

++         // if property is an alias, initialization expression is not a binding

++         if (!isAlias) {

++             parseResult =

++                     parseBindingExpression(publicMember->name.toString(), publicMember->statement,

++                                            publicMember);

++         }

++

++         // however, if we have a property with a script binding assigned to it,

++         // we have to create a new scope

++         if (parseResult == BindingExpressionParseResult::Script) {

++             Q_ASSERT(!m_savedBindingOuterScope); // automatically true due to grammar

++             m_savedBindingOuterScope = m_currentScope;

++             enterEnvironment(QQmlSA::ScopeType::BindingFunctionScope, QStringLiteral("binding"),

++                              publicMember->statement->firstSourceLocation());

++         }

++

++         break;

++     }

++     }

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(UiPublicMember *publicMember)

++ {

++     if (m_savedBindingOuterScope) {

++         m_currentScope = m_savedBindingOuterScope;

++         m_savedBindingOuterScope = {};

++         // m_savedBindingOuterScope is only set if we encounter a script binding

++         forgetFunctionExpression(publicMember->name.toString());

++     }

++ }

++

++ bool QQmlJSImportVisitor::visit(UiRequired *required)

++ {

++     const QString name = required->name.toString();

++

++     m_requiredProperties << RequiredProperty { m_currentScope, name,

++                                                required->firstSourceLocation() };

++

++     m_currentScope->setPropertyLocallyRequired(name, true);

++     return true;

++ }

++

++ void QQmlJSImportVisitor::visitFunctionExpressionHelper(QQmlJS::AST::FunctionExpression *fexpr)

++ {

++     using namespace QQmlJS::AST;

++     auto name = fexpr->name.toString();

++     if (!name.isEmpty()) {

++         QQmlJSMetaMethod method(name);

++         method.setMethodType(QQmlJSMetaMethodType::Method);

++         method.setSourceLocation(combine(fexpr->firstSourceLocation(), fexpr->lastSourceLocation()));

++

++         if (!m_pendingMethodAnnotations.isEmpty()) {

++             method.setAnnotations(m_pendingMethodAnnotations);

++             m_pendingMethodAnnotations.clear();

++         }

++

++         // If signatures are explicitly ignored, we don't parse the types

++         const bool parseTypes = m_scopesById.signaturesAreEnforced();

++

++         bool formalsFullyTyped = parseTypes;

++         bool anyFormalTyped = false;

++         PendingMethodTypeAnnotations pending{ m_currentScope, name, {} };

++

++         // We potentially iterate twice over formals

++         for (auto formals = fexpr->formals; formals; formals = formals->next) {

++             PatternElement *e = formals->element;

++             if (!e)

++                 continue;

++             if (e->typeAnnotation && (e->bindingTarget || e->initializer))

++                 m_logger->log("Type annotations on default parameters are not supported"_L1,

++                               qmlSyntax,

++                               combine(e->firstSourceLocation(), e->lastSourceLocation()));

++         }

++

++         if (const auto *formals = parseTypes ? fexpr->formals : nullptr) {

++             const auto parameters = formals->formals();

++             for (const auto &parameter : parameters) {

++                 const QString type = parameter.typeAnnotation

++                         ? parameter.typeAnnotation->type->toString()

++                         : QString();

++                 if (type.isEmpty()) {

++                     formalsFullyTyped = false;

++                     method.addParameter(QQmlJSMetaParameter(parameter.id, QStringLiteral("var")));

++                     pending.locations.emplace_back();

++                 }  else {

++                     anyFormalTyped = true;

++                     method.addParameter(QQmlJSMetaParameter(parameter.id, type));

++                     pending.locations.append(

++                             combine(parameter.typeAnnotation->firstSourceLocation(),

++                                     parameter.typeAnnotation->lastSourceLocation()));

++                 }

++             }

++         }

++

++         // If a function is fully typed, we can call it like a C++ function.

++         method.setIsJavaScriptFunction(!formalsFullyTyped);

++

++         // Methods with explicit return type return that.

++         // Methods with only untyped arguments return an untyped value.

++         // Methods with at least one typed argument but no explicit return type return void.

++         // In order to make a function without arguments return void, you have to specify that.

++         if (parseTypes && fexpr->typeAnnotation) {

++             method.setReturnTypeName(fexpr->typeAnnotation->type->toString());

++             pending.locations.append(combine(fexpr->typeAnnotation->firstSourceLocation(),

++                                              fexpr->typeAnnotation->lastSourceLocation()));

++         } else if (anyFormalTyped) {

++             method.setReturnTypeName(QStringLiteral("void"));

++         } else {

++             method.setReturnTypeName(QStringLiteral("var"));

++         }

++

++         const auto &locs = pending.locations;

++         if (std::any_of(locs.cbegin(), locs.cend(), [](const auto &loc) { return loc.isValid(); }))

++             m_pendingMethodTypeAnnotations << pending;

++

++         method.setCompiledFunctionIndex(addFunctionOrExpression(m_currentScope, method.methodName()));

++         method.setMethodIndex(

++                 QQmlJSMetaMethod::RelativeFunctionIndex(m_currentScope->ownMethods().size()));

++

++         if (m_currentScope->scopeType() != QQmlSA::ScopeType::QMLScope) {

++             // note: lambda methods have no identifier token

++             const QQmlJS::SourceLocation functionLocation = fexpr->identifierToken.isValid()

++                     ? fexpr->identifierToken

++                     : fexpr->functionToken;

++             safeInsertJSIdentifier(m_currentScope, name,

++                                    { QQmlJSScope::JavaScriptIdentifier::LexicalScoped,

++                                      functionLocation, method.returnTypeName(),

++                                      false });

++         }

++         m_currentScope->addOwnMethod(method);

++

++         enterEnvironment(QQmlSA::ScopeType::JSFunctionScope, name, fexpr->firstSourceLocation());

++     } else {

++         addFunctionOrExpression(m_currentScope, QStringLiteral("<anon>"));

++         enterEnvironment(QQmlSA::ScopeType::JSFunctionScope, QStringLiteral("<anon>"),

++                          fexpr->firstSourceLocation());

++     }

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::FunctionExpression *fexpr)

++ {

++     visitFunctionExpressionHelper(fexpr);

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::FunctionExpression *fexpr)

++ {

++     forgetFunctionExpression(fexpr->name.toString());

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiSourceElement *srcElement)

++ {

++     m_pendingMethodAnnotations = parseAnnotations(srcElement->annotations);

++     return true;

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::FunctionDeclaration *fdecl)

++ {

++     if (!fdecl->name.isEmpty()) {

++         const QString name = fdecl->name.toString();

++         if (auto previousDeclaration = m_currentScope->ownJSIdentifier(name)) {

++             m_logger->log("Identifier '%1' has already been declared"_L1.arg(name), qmlSyntax,

++                           fdecl->identifierToken);

++             m_logger->log("Note: previous declaration of '%1' here"_L1.arg(name), qmlSyntax,

++                           previousDeclaration->location);

++         }

++     }

++     visitFunctionExpressionHelper(fdecl);

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::FunctionDeclaration *fdecl)

++ {

++     forgetFunctionExpression(fdecl->name.toString());

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::ClassExpression *ast)

++ {

++     QQmlJSMetaProperty prop;

++     prop.setPropertyName(ast->name.toString());

++     m_currentScope->addOwnProperty(prop);

++     enterEnvironment(QQmlSA::ScopeType::JSFunctionScope, ast->name.toString(),

++                      ast->firstSourceLocation());

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::ClassExpression *)

++ {

++     leaveEnvironment();

++ }

++

++ void handleTranslationBinding(QQmlJSMetaPropertyBinding &binding, QStringView base,

++                               QQmlJS::AST::ArgumentList *args)

++ {

++     QStringView contextString;

++     QStringView mainString;

++     QStringView commentString;

++     auto registerContextString = [&](QStringView string) {

++         contextString = string;

++         return 0;

++     };

++     auto registerMainString = [&](QStringView string) {

++         mainString = string;

++         return 0;

++     };

++     auto registerCommentString = [&](QStringView string) {

++         commentString = string;

++         return 0;

++     };

++     auto finalizeBinding = [&](QV4::CompiledData::Binding::Type type,

++                                QV4::CompiledData::TranslationData data) {

++         if (type == QV4::CompiledData::Binding::Type_Translation) {

++             binding.setTranslation(mainString, commentString, contextString, data.number);

++         } else if (type == QV4::CompiledData::Binding::Type_TranslationById) {

++             binding.setTranslationId(mainString, data.number);

++         } else {

++             binding.setStringLiteral(mainString);

++         }

++     };

++     QmlIR::tryGeneratingTranslationBindingBase(

++                 base, args,

++                 registerMainString, registerCommentString, registerContextString, finalizeBinding);

++ }

++

++ QQmlJSImportVisitor::BindingExpressionParseResult

++ QQmlJSImportVisitor::parseBindingExpression(

++         const QString &name, const QQmlJS::AST::Statement *statement,

++         const UiPublicMember *associatedPropertyDefinition)

++ {

++     if (statement == nullptr)

++         return BindingExpressionParseResult::Invalid;

++

++     const auto *exprStatement = cast<const ExpressionStatement *>(statement);

++

++     if (exprStatement == nullptr) {

++         QQmlJS::SourceLocation location = statement->firstSourceLocation();

++

++         if (const auto *block = cast<const Block *>(statement); block && block->statements) {

++             location = block->statements->firstSourceLocation();

++         }

++

++         QQmlJSMetaPropertyBinding binding(location, name);

++         binding.setScriptBinding(addFunctionOrExpression(m_currentScope, name),

++                                  QQmlSA::ScriptBindingKind::PropertyBinding, ScriptValue_Function);

++         m_bindings.append(UnfinishedBinding {

++             m_currentScope,

++             [binding = std::move(binding)]() { return binding; }

++         });

++         return BindingExpressionParseResult::Script;

++     }

++

++     auto expr = exprStatement->expression;

++     QQmlJSMetaPropertyBinding binding(

++                 combine(expr->firstSourceLocation(), expr->lastSourceLocation()),

++                 name);

++

++     ScriptBindingValueType scriptBindingValuetype = ScriptValue_Unknown;

++

++     switch (expr->kind) {

++     case Node::Kind_TrueLiteral:

++         binding.setBoolLiteral(true);

++         break;

++     case Node::Kind_FalseLiteral:

++         binding.setBoolLiteral(false);

++         break;

++     case Node::Kind_NullExpression:

++         binding.setNullLiteral();

++         break;

++     case Node::Kind_IdentifierExpression: {

++         auto idExpr = QQmlJS::AST::cast<QQmlJS::AST::IdentifierExpression *>(expr);

++         Q_ASSERT(idExpr);

++         if (idExpr->name == u"undefined")

++             scriptBindingValuetype = ScriptValue_Undefined;

++         break;

++     }

++     case Node::Kind_FunctionDeclaration:

++     case Node::Kind_FunctionExpression:

++     case Node::Kind_Block: {

++         scriptBindingValuetype = ScriptValue_Function;

++         break;

++     }

++     case Node::Kind_NumericLiteral:

++         binding.setNumberLiteral(cast<NumericLiteral *>(expr)->value);

++         break;

++     case Node::Kind_StringLiteral:

++         binding.setStringLiteral(cast<StringLiteral *>(expr)->value);

++         break;

++     case Node::Kind_RegExpLiteral:

++         binding.setRegexpLiteral(cast<RegExpLiteral *>(expr)->pattern);

++         break;

++     case Node::Kind_TemplateLiteral: {

++         auto templateLit = QQmlJS::AST::cast<QQmlJS::AST::TemplateLiteral *>(expr);

++         Q_ASSERT(templateLit);

++         if (templateLit->hasNoSubstitution) {

++             binding.setStringLiteral(templateLit->value);

++         } else {

++             binding.setScriptBinding(addFunctionOrExpression(m_currentScope, name),

++                                      QQmlSA::ScriptBindingKind::PropertyBinding);

++             for (QQmlJS::AST::TemplateLiteral *l = templateLit; l; l = l->next) {

++                 if (QQmlJS::AST::ExpressionNode *expression = l->expression)

++                     expression->accept(this);

++             }

++         }

++         break;

++     }

++     default:

++         if (QQmlJS::AST::UnaryMinusExpression *unaryMinus = QQmlJS::AST::cast<QQmlJS::AST::UnaryMinusExpression *>(expr)) {

++             if (QQmlJS::AST::NumericLiteral *lit = QQmlJS::AST::cast<QQmlJS::AST::NumericLiteral *>(unaryMinus->expression))

++                 binding.setNumberLiteral(-lit->value);

++         } else if (QQmlJS::AST::CallExpression *call = QQmlJS::AST::cast<QQmlJS::AST::CallExpression *>(expr)) {

++             if (QQmlJS::AST::IdentifierExpression *base = QQmlJS::AST::cast<QQmlJS::AST::IdentifierExpression *>(call->base))

++                 handleTranslationBinding(binding, base->name, call->arguments);

++         }

++         break;

++     }

++

++     if (!binding.isValid()) {

++         // consider this to be a script binding (see IRBuilder::setBindingValue)

++         binding.setScriptBinding(addFunctionOrExpression(m_currentScope, name),

++                                  QQmlSA::ScriptBindingKind::PropertyBinding,

++                                  scriptBindingValuetype);

++     }

++     m_bindings.append(UnfinishedBinding { m_currentScope, [=]() { return binding; } });

++

++     // translations are neither literal bindings nor script bindings

++     if (binding.bindingType() == QQmlSA::BindingType::Translation

++         || binding.bindingType() == QQmlSA::BindingType::TranslationById) {

++         return BindingExpressionParseResult::Translation;

++     }

++     if (!QQmlJSMetaPropertyBinding::isLiteralBinding(binding.bindingType()))

++         return BindingExpressionParseResult::Script;

++

++     if (associatedPropertyDefinition)

++         handleLiteralBinding(binding, associatedPropertyDefinition);

++

++     return BindingExpressionParseResult::Literal;

++ }

++

++ bool QQmlJSImportVisitor::isImportPrefix(QString prefix) const

++ {

++     if (prefix.isEmpty() || !prefix.front().isUpper())

++         return false;

++

++     return m_rootScopeImports.isNullType(prefix);

++ }

++

++ void QQmlJSImportVisitor::handleIdDeclaration(QQmlJS::AST::UiScriptBinding *scriptBinding)

++ {

++     if (m_currentScope->scopeType() != QQmlJSScope::ScopeType::QMLScope) {

++         m_logger->log(u"id declarations are only allowed in objects"_s, qmlSyntax,

++                       scriptBinding->statement->firstSourceLocation());

++         return;

++     }

++     const auto *statement = cast<ExpressionStatement *>(scriptBinding->statement);

++     if (!statement) {

++         m_logger->log(u"id must be followed by an identifier"_s, qmlSyntax,

++                       scriptBinding->statement->firstSourceLocation());

++         return;

++     }

++     const QString name = [&]() {

++         if (const auto *idExpression = cast<IdentifierExpression *>(statement->expression))

++             return idExpression->name.toString();

++         else if (const auto *idString = cast<StringLiteral *>(statement->expression)) {

++             m_logger->log(u"ids do not need quotation marks"_s, qmlSyntaxIdQuotation,

++                           idString->firstSourceLocation());

++             return idString->value.toString();

++         }

++         m_logger->log(u"Failed to parse id"_s, qmlSyntax,

++                       statement->expression->firstSourceLocation());

++         return QString();

++     }();

++

++     if (!name.isEmpty() && !name.front().isLower() && name.front() != u'_') {

++         m_logger->log(u"Id must start with a lower case letter or an '_'"_s, qmlSyntax,

++                       statement->expression->firstSourceLocation());

++     }

++

++     m_currentScope->setIdSourceLocation(combine(scriptBinding->statement->firstSourceLocation(),

++                                                 scriptBinding->statement->lastSourceLocation()));

++     if (m_scopesById.existsAnywhereInDocument(name)) {

++         // ### TODO: find an alternative to breakInhertianceCycles here

++         // we shouldn't need to search for the current root component in any case here

++         breakInheritanceCycles(m_currentScope);

++         m_scopesById.possibleScopes(

++                 name, m_currentScope, QQmlJSScopesByIdOption::Default,

++                 [&](const QQmlJSScope::ConstPtr &otherScopeWithID,

++                     QQmlJSScopesById::Confidence confidence) {

++             // If it's a fuzzy match, that's still warning-worthy

++             Q_UNUSED(confidence);

++

++             auto otherLocation = otherScopeWithID->sourceLocation();

++

++             // critical because subsequent analysis cannot cope with messed up ids

++             // and the file is invalid

++             m_logger->log(u"Found a duplicated id. id %1 was first declared at %2:%3"_s.arg(

++                                   name, QString::number(otherLocation.startLine),

++                                   QString::number(otherLocation.startColumn)),

++                           qmlSyntaxDuplicateIds, // ??

++                           scriptBinding->firstSourceLocation());

++             return QQmlJSScopesById::CallbackResult::ContinueSearch;

++         });

++     }

++     if (!name.isEmpty())

++         m_scopesById.insert(name, m_currentScope);

++ }

++

++ void QQmlJSImportVisitor::handleLiteralBinding(const QQmlJSMetaPropertyBinding &binding,

++                                                const UiPublicMember *associatedPropertyDefinition)

++ {

++     // stub

++     Q_UNUSED(binding);

++     Q_UNUSED(associatedPropertyDefinition);

++ }

++

++ /*! \internal

++

++     Creates a new binding of either a GroupedProperty or an AttachedProperty type.

++     The binding is added to the parentScope() of \a scope, under property name

++     \a name and location \a srcLocation.

++ */

++ inline QQmlJSImportVisitor::UnfinishedBinding

++ createNonUniqueScopeBinding(QQmlJSScope::Ptr &scope, const QString &name,

++                             const QQmlJS::SourceLocation &srcLocation)

++ {

++     const auto createBinding = [=]() {

++         const QQmlJSScope::ScopeType type = scope->scopeType();

++         Q_ASSERT(type == QQmlSA::ScopeType::GroupedPropertyScope

++                  || type == QQmlSA::ScopeType::AttachedPropertyScope);

++         const QQmlSA::BindingType bindingType = (type == QQmlSA::ScopeType::GroupedPropertyScope)

++                 ? QQmlSA::BindingType::GroupedProperty

++                 : QQmlSA::BindingType::AttachedProperty;

++

++         const auto propertyBindings = scope->parentScope()->ownPropertyBindings(name);

++         const bool alreadyHasBinding = std::any_of(propertyBindings.first, propertyBindings.second,

++                                                    [&](const QQmlJSMetaPropertyBinding &binding) {

++                                                        return binding.bindingType() == bindingType;

++                                                    });

++         if (alreadyHasBinding) // no need to create any more

++             return QQmlJSMetaPropertyBinding(QQmlJS::SourceLocation {});

++

++         QQmlJSMetaPropertyBinding binding(srcLocation, name);

++         if (type == QQmlSA::ScopeType::GroupedPropertyScope)

++             binding.setGroupBinding(static_cast<QSharedPointer<QQmlJSScope>>(scope));

++         else

++             binding.setAttachedBinding(static_cast<QSharedPointer<QQmlJSScope>>(scope));

++         return binding;

++     };

++     return { scope->parentScope(), createBinding };

++ }

++

++ bool QQmlJSImportVisitor::visit(UiScriptBinding *scriptBinding)

++ {

++     Q_ASSERT(!m_savedBindingOuterScope); // automatically true due to grammar

++     Q_ASSERT(!m_thisScriptBindingIsJavaScript); // automatically true due to grammar

++     m_savedBindingOuterScope = m_currentScope;

++     const auto id = scriptBinding->qualifiedId;

++     if (!id->next && id->name == QLatin1String("id")) {

++         handleIdDeclaration(scriptBinding);

++         return true;

++     }

++

++     auto group = id;

++

++     QString prefix;

++     for (; group->next; group = group->next) {

++         const QString name = group->name.toString();

++         if (name.isEmpty())

++             break;

++

++         if (group == id && isImportPrefix(name)) {

++             prefix = name + u'.';

++             continue;

++         }

++

++         const bool isAttachedProperty = name.front().isUpper();

++         if (isAttachedProperty) {

++             // attached property

++             enterEnvironmentNonUnique(QQmlSA::ScopeType::AttachedPropertyScope, prefix + name,

++                                       group->firstSourceLocation());

++         } else {

++             // grouped property

++             enterEnvironmentNonUnique(QQmlSA::ScopeType::GroupedPropertyScope, prefix + name,

++                                       group->firstSourceLocation());

++         }

++         m_bindings.append(createNonUniqueScopeBinding(m_currentScope, prefix + name,

++                                                       group->firstSourceLocation()));

++

++         prefix.clear();

++     }

++

++     const auto name = group->name.toString();

++

++     // This is a preliminary check.

++     // Even if the name starts with "on", it might later turn out not to be a signal.

++     const auto signal = QQmlSignalNames::handlerNameToSignalName(name);

++

++     if (!signal.has_value() || m_currentScope->hasProperty(name)) {

++         m_propertyBindings[m_currentScope].append(

++                 { m_savedBindingOuterScope, group->firstSourceLocation(), name });

++         // ### TODO: report Invalid parse status as a warning/error

++         auto result = parseBindingExpression(name, scriptBinding->statement);

++         m_thisScriptBindingIsJavaScript = (result == BindingExpressionParseResult::Script);

++     } else {

++         const auto statement = scriptBinding->statement;

++         QStringList signalParameters;

++

++         if (ExpressionStatement *expr = cast<ExpressionStatement *>(statement)) {

++             if (FunctionExpression *func = expr->expression->asFunctionDefinition()) {

++                 for (FormalParameterList *formal = func->formals; formal; formal = formal->next)

++                     signalParameters << formal->element->bindingIdentifier.toString();

++             }

++         }

++

++         QQmlJSMetaMethod scopeSignal;

++         const auto methods = m_currentScope->methods(*signal, QQmlJSMetaMethodType::Signal);

++         if (!methods.isEmpty())

++             scopeSignal = methods[0];

++

++         const auto firstSourceLocation = statement->firstSourceLocation();

++         bool hasMultilineStatementBody =

++                 statement->lastSourceLocation().startLine > firstSourceLocation.startLine;

++         m_pendingSignalHandler = firstSourceLocation;

++         m_signalHandlers.insert(firstSourceLocation,

++                                 { scopeSignal.parameterNames(), hasMultilineStatementBody });

++

++         // NB: calculate runtime index right away to avoid miscalculation due to

++         // losing real AST traversal order

++         const auto index = addFunctionOrExpression(m_currentScope, name);

++         const auto createBinding = [

++                 this,

++                 scope = m_currentScope,

++                 signalName = *signal,

++                 index,

++                 name,

++                 firstSourceLocation,

++                 groupLocation = group->firstSourceLocation(),

++                 signalParameters]() {

++             // when encountering a signal handler, add it as a script binding

++             Q_ASSERT(scope->isFullyResolved());

++             QQmlSA::ScriptBindingKind kind = QQmlSA::ScriptBindingKind::Invalid;

++             const auto methods = scope->methods(signalName, QQmlJSMetaMethodType::Signal);

++             if (!methods.isEmpty()) {

++                 kind = QQmlSA::ScriptBindingKind::SignalHandler;

++                 checkSignal(scope, groupLocation, name, signalParameters);

++             } else if (QQmlJSUtils::propertyFromChangedHandler(scope, name).has_value()) {

++                 kind = QQmlSA::ScriptBindingKind::ChangeHandler;

++                 checkSignal(scope, groupLocation, name, signalParameters);

++             } else if (scope->hasProperty(name)) {

++                 // Not a signal handler after all.

++                 // We can see this now because the type is fully resolved.

++                 kind = QQmlSA::ScriptBindingKind::PropertyBinding;

++                 m_signalHandlers.remove(firstSourceLocation);

++             } else {

++                 // We already know it's bad, but let's allow checkSignal() to do its thing.

++                 checkSignal(scope, groupLocation, name, signalParameters);

++             }

++

++             QQmlJSMetaPropertyBinding binding(firstSourceLocation, name);

++             binding.setScriptBinding(index, kind, ScriptValue_Function);

++             return binding;

++         };

++         m_bindings.append(UnfinishedBinding { m_currentScope, createBinding });

++         m_thisScriptBindingIsJavaScript = true;

++     }

++

++     // TODO: before leaving the scopes, we must create the binding.

++

++     // Leave any group/attached scopes so that the binding scope doesn't see its properties.

++     while (m_currentScope->scopeType() == QQmlSA::ScopeType::GroupedPropertyScope

++            || m_currentScope->scopeType() == QQmlSA::ScopeType::AttachedPropertyScope) {

++         leaveEnvironment();

++     }

++

++     if (signal) {

++         enterEnvironment(QQmlSA::ScopeType::SignalHandlerFunctionScope,

++                      u"signalHandler"_s,

++                      scriptBinding->statement->firstSourceLocation());

++     } else {

++         enterEnvironment(QQmlSA::ScopeType::BindingFunctionScope,

++                          u"binding"_s,

++                          scriptBinding->statement->firstSourceLocation());

++     }

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(UiScriptBinding *)

++ {

++     if (m_savedBindingOuterScope) {

++         m_currentScope = m_savedBindingOuterScope;

++         m_savedBindingOuterScope = {};

++     }

++

++     // forgetFunctionExpression() but without the name check since script

++     // bindings are special (script bindings only sometimes result in java

++     // script bindings. e.g. a literal binding is also a UiScriptBinding)

++     if (m_thisScriptBindingIsJavaScript) {

++         m_thisScriptBindingIsJavaScript = false;

++         Q_ASSERT(!m_functionStack.isEmpty());

++         m_functionStack.pop();

++     }

++ }

++

++ bool QQmlJSImportVisitor::visit(UiArrayBinding *arrayBinding)

++ {

++     createAttachedAndGroupedScopes(arrayBinding->qualifiedId);

++     enterEnvironment(QQmlSA::ScopeType::QMLScope, buildName(arrayBinding->qualifiedId),

++                      arrayBinding->firstSourceLocation());

++     m_currentScope->setIsArrayScope(true);

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(UiArrayBinding *arrayBinding)

++ {

++     // immediate children (QML scopes) of m_currentScope are the objects inside

++     // the array binding. note that we always work with object bindings here as

++     // this is the only kind of bindings that UiArrayBinding is created for. any

++     // other expressions involving lists (e.g. `var p: [1,2,3]`) are considered

++     // to be script bindings

++     const auto children = m_currentScope->childScopes();

++     leaveEnvironment();

++

++     const int scopesEnteredCounter = openAttachedAndGroupedScopes(arrayBinding->qualifiedId);

++     auto guard = qScopeGuard([this, scopesEnteredCounter]() {

++         for (int i = 0; i < scopesEnteredCounter; ++i)

++             leaveEnvironment();

++     });

++

++     if (checkCustomParser(m_currentScope)) {

++         // These warnings do not apply for custom parsers and their children and need to be handled

++         // on a case by case basis

++         return;

++     }

++

++     auto group = arrayBinding->qualifiedId;

++     for (; group->next; group = group->next) { }

++     const QString propertyName = group->name.toString();

++

++     qsizetype i = 0;

++     for (auto element = arrayBinding->members; element; element = element->next, ++i) {

++         const auto &type = children[i];

++         if ((type->scopeType() != QQmlSA::ScopeType::QMLScope)) {

++             m_logger->log(u"Declaring an object which is not a Qml object"

++                           " as a list member."_s, qmlSyntax, element->firstSourceLocation());

++             return;

++         }

++         m_pendingPropertyObjectBindings

++                 << PendingPropertyObjectBinding { m_currentScope, type, propertyName,

++                                                   element->firstSourceLocation(), false };

++         QQmlJSMetaPropertyBinding binding(element->firstSourceLocation(), propertyName);

++         binding.setObject(QQmlJSUtils::getScopeName(type, QQmlSA::ScopeType::QMLScope),

++                           QQmlJSScope::ConstPtr(type));

++         m_bindings.append(UnfinishedBinding {

++             m_currentScope,

++             [binding = std::move(binding)]() { return binding; },

++             QQmlJSScope::ListPropertyTarget

++         });

++     }

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiEnumDeclaration *uied)

++ {

++     QQmlJSMetaEnum qmlEnum(uied->name.toString());

++     qmlEnum.setIsQml(true);

++     qmlEnum.setLineNumber(uied->enumToken.startLine);

++     for (const auto *member = uied->members; member; member = member->next) {

++         qmlEnum.addKey(member->member.toString());

++         qmlEnum.addValue(int(member->value));

++     }

++     m_currentScope->addOwnEnumeration(qmlEnum);

++     return true;

++ }

++

++ QList<QQmlJS::DiagnosticMessage> QQmlJSImportVisitor::importFromHost(

++         const QString &path, const QString &prefix, const QQmlJS::SourceLocation &location)

++ {

++     QFileInfo fileInfo(path);

++     if (!fileInfo.exists()) {

++         m_logger->log("File or directory you are trying to import does not exist: %1."_L1.arg(path),

++                       qmlImport, location);

++         return {};

++     }

++

++     if (fileInfo.isFile()) {

++         const auto scope = m_importer->importFile(path);

++         const QString actualPrefix = prefix.isEmpty() ? scope->internalName() : prefix;

++         auto precedence = quint8(QQmlJS::PrecedenceValues::Default);

++         m_rootScopeImports.setType(actualPrefix, { scope, QTypeRevision(), precedence });

++         addImportWithLocation(actualPrefix, location, false);

++         return {};

++     }

++

++     if (fileInfo.isDir()) {

++         auto precedence = quint8(QQmlJS::PrecedenceValues::Default);

++         auto scopes = m_importer->importDirectory(path, precedence, prefix);

++         m_importer->registerVersionedImports(scopes);

++         const auto types = scopes.types();

++         const auto warnings = scopes.warnings();

++         m_rootScopeImports.add(std::move(scopes));

++         for (auto it = types.keyBegin(), end = types.keyEnd(); it != end; it++)

++             addImportWithLocation(*it, location, !warnings.isEmpty());

++         return warnings;

++     }

++

++     m_logger->log(

++             "%1 is neither a file nor a directory. Are sure the import path is correct?"_L1.arg(

++                     path),

++             qmlImport, location);

++     return {};

++ }

++

++ QList<QQmlJS::DiagnosticMessage> QQmlJSImportVisitor::importFromQrc(

++         const QString &path, const QString &prefix, const QQmlJS::SourceLocation &location)

++ {

++     Q_ASSERT(path.startsWith(u':'));

++     const QQmlJSResourceFileMapper *mapper = m_importer->resourceFileMapper();

++     if (!mapper)

++         return {};

++

++     const auto pathNoColon = QStringView(path).mid(1);

++     if (mapper->isFile(pathNoColon)) {

++         const auto entry = m_importer->resourceFileMapper()->entry(

++                 QQmlJSResourceFileMapper::resourceFileFilter(pathNoColon.toString()));

++         const auto scope = m_importer->importFile(entry.filePath);

++         const QString actualPrefix =

++                 prefix.isEmpty() ? QFileInfo(entry.resourcePath).baseName() : prefix;

++         auto precedence = quint8(QQmlJS::PrecedenceValues::Default);

++         m_rootScopeImports.setType(actualPrefix, { scope, QTypeRevision(), precedence });

++         addImportWithLocation(actualPrefix, location, false);

++         return {};

++     }

++

++     auto scopes = m_importer->importDirectory(path, quint8(QQmlJS::PrecedenceValues::Default), prefix);

++     m_importer->registerVersionedImports(scopes);

++     const auto types = scopes.types();

++     const auto warnings = scopes.warnings();

++     m_rootScopeImports.add(std::move(scopes));

++     for (auto it = types.keyBegin(), end = types.keyEnd(); it != end; it++)

++         addImportWithLocation(*it, location, !warnings.isEmpty());

++     return warnings;

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiImport *import)

++ {

++     // construct path

++     QString prefix = QLatin1String("");

++     if (import->asToken.isValid()) {

++         prefix += import->importId;

++         if (!import->importId.isEmpty() && !import->importId.front().isUpper()) {

++             m_logger->log(u"Import qualifier '%1' must start with a capital letter."_s.arg(

++                                   import->importId),

++                           qmlImport, import->importIdToken, true, true);

++         }

++         m_seenModuleQualifiers.append(prefix);

++     }

++

++     const QString filename = import->fileName.toString();

++     if (!filename.isEmpty()) {

++         const QUrl url(filename);

++         const QString scheme = url.scheme();

++         const QQmlJS::SourceLocation importLocation = import->firstSourceLocation();

++         if (scheme == ""_L1) {

++             QFileInfo fileInfo(url.path());

++             QString absolute = fileInfo.isRelative()

++                     ? QDir::cleanPath(QDir(m_implicitImportDirectory).filePath(filename))

++                     : filename;

++             auto warnings = absolute.startsWith(u':')

++                     ? importFromQrc(absolute, prefix, importLocation)

++                     : importFromHost(absolute, prefix, importLocation);

++             processImportWarnings("path \"%1\""_L1.arg(url.path()), warnings, importLocation);

++             return true;

++         } else if (scheme == "file"_L1) {

++             auto warnings = importFromHost(url.path(), prefix, importLocation);

++             processImportWarnings("URL \"%1\""_L1.arg(url.path()), warnings, importLocation);

++             return true;

++         } else if (scheme == "qrc"_L1) {

++             auto warnings = importFromQrc(":"_L1 + url.path(), prefix, importLocation);

++             processImportWarnings("URL \"%1\""_L1.arg(url.path()), warnings, importLocation);

++             return true;

++         } else {

++             m_logger->log("Unknown import syntax. Imports can be paths, qrc urls or file urls"_L1,

++                           qmlImport, import->firstSourceLocation());

++         }

++     }

++

++     const QString path = buildName(import->importUri);

++

++     QStringList staticModulesProvided;

++

++     auto imported = m_importer->importModule(

++             path, quint8(QQmlJS::PrecedenceValues::Default), prefix,

++             import->version ? import->version->version : QTypeRevision(), &staticModulesProvided);

++     m_importer->registerVersionedImports(imported);

++     const auto types = imported.types();

++     const auto warnings = imported.warnings();

++     m_rootScopeImports.add(std::move(imported));

++     for (auto it = types.keyBegin(), end = types.keyEnd(); it != end; it++)

++         addImportWithLocation(*it, import->firstSourceLocation(), !warnings.isEmpty());

++

++     if (prefix.isEmpty()) {

++         for (const QString &staticModule : std::as_const(staticModulesProvided))

++             addStaticImportWithLocation(path, import->firstSourceLocation(), path != staticModule);

++     }

++

++     processImportWarnings(

++             QStringLiteral("module \"%1\"").arg(path), warnings, import->firstSourceLocation());

++     return true;

++ }

++

++ #if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)

++ template<typename F>

++ void handlePragmaValues(QQmlJS::AST::UiPragma *pragma, F &&assign)

++ {

++     for (const QQmlJS::AST::UiPragmaValueList *v = pragma->values; v; v = v->next)

++         assign(v->value);

++ }

++ #else

++ template<typename F>

++ void handlePragmaValues(QQmlJS::AST::UiPragma *pragma, F &&assign)

++ {

++     assign(pragma->value);

++ }

++ #endif

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiPragma *pragma)

++ {

++     if (pragma->name == u"Strict"_s) {

++         // If a file uses pragma Strict, it expects to be compiled, so automatically

++         // enable compiler warnings unless the severity is set explicitly already (e.g.

++         // by the user).

++

++         if (!m_logger->wasCategoryChanged(qmlCompiler))

++             m_logger->setCategorySeverity(qmlCompiler, QQmlJS::WarningSeverity::Warning);

++     } else if (pragma->name == u"ComponentBehavior") {

++         handlePragmaValues(pragma, [this, pragma](QStringView value) {

++             if (value == u"Bound") {

++                 m_scopesById.setComponentsAreBound(true);

++             } else if (value == u"Unbound") {

++                 m_scopesById.setComponentsAreBound(false);

++             } else {

++                 m_logger->log(u"Unknown argument \"%1\" to pragma ComponentBehavior"_s.arg(value),

++                               qmlSyntax, pragma->firstSourceLocation());

++             }

++         });

++     } else if (pragma->name == u"FunctionSignatureBehavior") {

++         handlePragmaValues(pragma, [this, pragma](QStringView value) {

++             if (value == u"Enforced") {

++                 m_scopesById.setSignaturesAreEnforced(true);

++             } else if (value == u"Ignored") {

++                 m_scopesById.setSignaturesAreEnforced(false);

++             } else {

++                 m_logger->log(

++                         u"Unknown argument \"%1\" to pragma FunctionSignatureBehavior"_s.arg(value),

++                         qmlSyntax, pragma->firstSourceLocation());

++             }

++         });

++     } else if (pragma->name == u"ValueTypeBehavior") {

++         handlePragmaValues(pragma, [this, pragma](QStringView value) {

++             if (value == u"Copy") {

++                 // Ignore

++             } else if (value == u"Reference") {

++                 // Ignore

++             } else if (value == u"Addressable") {

++                 m_scopesById.setValueTypesAreAddressable(true);

++             } else if (value == u"Inaddressable") {

++                 m_scopesById.setValueTypesAreAddressable(false);

++             } else if (value == u"Assertable") {

++                 m_scopesById.setValueTypesAreAssertable(true);

++             } else if (value == u"Inassertable") {

++                 m_scopesById.setValueTypesAreAssertable(false);

++             } else {

++                 m_logger->log(u"Unknown argument \"%1\" to pragma ValueTypeBehavior"_s.arg(value),

++                               qmlSyntax, pragma->firstSourceLocation());

++             }

++         });

++     }

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::throwRecursionDepthError()

++ {

++     m_logger->log(QStringLiteral("Maximum statement or expression depth exceeded"),

++                   qmlRecursionDepthErrors, QQmlJS::SourceLocation());

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::ClassDeclaration *ast)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSFunctionScope, ast->name.toString(),

++                      ast->firstSourceLocation());

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::ClassDeclaration *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::ForStatement *ast)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("forloop"),

++                      ast->firstSourceLocation());

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::ForStatement *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::ForEachStatement *ast)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("foreachloop"),

++                      ast->firstSourceLocation());

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::ForEachStatement *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::Block *ast)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("block"),

++                      ast->firstSourceLocation());

++

++     if (m_pendingSignalHandler.isValid())

++         flushPendingSignalParameters();

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::Block *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::CaseBlock *ast)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("case"),

++                      ast->firstSourceLocation());

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::CaseBlock *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::Catch *catchStatement)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("catch"),

++                      catchStatement->firstSourceLocation());

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::Catch *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::WithStatement *ast)

++ {

++     enterEnvironment(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("with"),

++                      ast->firstSourceLocation());

++

++     m_logger->log(QStringLiteral("with statements are strongly discouraged in QML "

++                                  "and might cause false positives when analysing unqualified "

++                                  "identifiers"),

++                   qmlWith, ast->firstSourceLocation());

++

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::WithStatement *)

++ {

++     leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::FormalParameterList *fpl)

++ {

++     const auto &boundedNames = fpl->boundNames();

++     for (auto const &boundName : boundedNames) {

++

++         std::optional<QString> typeName;

++         if (TypeAnnotation *annotation = boundName.typeAnnotation.data())

++             if (Type *type = annotation->type)

++                 typeName = type->toString();

++         safeInsertJSIdentifier(m_currentScope, boundName.id,

++                                            { QQmlJSScope::JavaScriptIdentifier::Parameter,

++                                              boundName.location, typeName, false });

++     }

++     return true;

++ }

++

++ void QQmlJSImportVisitor::createAttachedAndGroupedScopes(UiQualifiedId *propertyName)

++ {

++     bool needsResolution = false;

++     int scopesEnteredCounter = 0;

++     QString prefix;

++     for (auto group = propertyName; group->next; group = group->next) {

++         const QString idName = group->name.toString();

++

++         if (idName.isEmpty())

++             break;

++

++         if (group == propertyName && isImportPrefix(idName)) {

++             prefix = idName + u'.';

++             continue;

++         }

++

++         const auto scopeKind = idName.front().isUpper() ? QQmlSA::ScopeType::AttachedPropertyScope

++                                                         : QQmlSA::ScopeType::GroupedPropertyScope;

++

++         bool exists =

++                 enterEnvironmentNonUnique(scopeKind, prefix + idName, group->firstSourceLocation());

++

++         m_bindings.append(createNonUniqueScopeBinding(m_currentScope, prefix + idName,

++                                                       group->firstSourceLocation()));

++

++         ++scopesEnteredCounter;

++         needsResolution = needsResolution || !exists;

++

++         prefix.clear();

++     }

++

++     for (int i=0; i < scopesEnteredCounter; ++i) { // leave the scopes we entered again

++         leaveEnvironment();

++     }

++

++     // recursively resolve types for current scope if new scopes are found

++     if (needsResolution) {

++         QQmlJSScope::resolveTypes(m_currentScope, m_rootScopeImports.contextualTypes(),

++                                   usedTypes());

++     }

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::UiObjectBinding *uiob)

++ {

++     // ... __styleData: QtObject {...}

++

++     Q_ASSERT(uiob->qualifiedTypeNameId);

++

++     const QString typeName = buildName(uiob->qualifiedTypeNameId);

++     if (typeName.front().isLower() && typeName.contains(u'.')) {

++         logLowerCaseImport(typeName, uiob->qualifiedTypeNameId->identifierToken, m_logger);

++     }

++

++     createAttachedAndGroupedScopes(uiob->qualifiedId);

++

++     enterEnvironment(QQmlSA::ScopeType::QMLScope, typeName,

++                      uiob->qualifiedTypeNameId->identifierToken);

++

++     m_qmlTypes.append(m_currentScope); // new QMLScope is created here, so add it

++     m_objectBindingScopes << m_currentScope;

++     return true;

++ }

++

++ int QQmlJSImportVisitor::openAttachedAndGroupedScopes(UiQualifiedId *propertyName)

++ {

++     QString prefix;

++     int scopesEnteredCounter = 0;

++     auto group = propertyName;

++     for (; group->next; group = group->next) {

++         const QString idName = group->name.toString();

++

++         if (idName.isEmpty())

++             break;

++

++         if (group == propertyName && isImportPrefix(idName)) {

++             prefix = idName + u'.';

++             continue;

++         }

++

++         const auto scopeKind = idName.front().isUpper() ? QQmlSA::ScopeType::AttachedPropertyScope

++                                                         : QQmlSA::ScopeType::GroupedPropertyScope;

++         // definitely exists

++         [[maybe_unused]] bool exists =

++                 enterEnvironmentNonUnique(scopeKind, prefix + idName, group->firstSourceLocation());

++         Q_ASSERT(exists);

++         scopesEnteredCounter++;

++

++         prefix.clear();

++     }

++     return scopesEnteredCounter;

++ }

++

++ void QQmlJSImportVisitor::endVisit(QQmlJS::AST::UiObjectBinding *uiob)

++ {

++     QQmlJSScope::resolveTypes(m_currentScope, m_rootScopeImports.contextualTypes(), usedTypes());

++     // must be mutable, as we might mark it as implicitly wrapped in a component

++     const QQmlJSScope::Ptr childScope = m_currentScope;

++     leaveEnvironment();

++

++     const int scopesEnteredCounter = openAttachedAndGroupedScopes(uiob->qualifiedId);

++

++     // on ending the visit to UiObjectBinding, set the property type to the

++     // just-visited one if the property exists and this type is valid

++

++     auto group = uiob->qualifiedId;

++     for (; group->next; group = group->next) { }

++     const QString propertyName = group->name.toString();

++

++     if (m_currentScope->isNameDeferred(propertyName)) {

++         bool foundIds = false;

++         QList<QQmlJSScope::ConstPtr> childScopes { childScope };

++

++         while (!childScopes.isEmpty()) {

++             const QQmlJSScope::ConstPtr scope = childScopes.takeFirst();

++             m_scopesById.possibleIds(

++                     scope, scope, QQmlJSScopesByIdOption::Default,

++                     [&](const QString &id, QQmlJSScopesById::Confidence confidence) {

++                 // Any ID is enough to trigger the warning, no matter how confident we are about it.

++                 Q_UNUSED(id);

++                 Q_UNUSED(confidence);

++                 foundIds = true;

++                 return QQmlJSScopesById::CallbackResult::StopSearch;

++             });

++

++             childScopes << scope->childScopes();

++         }

++

++         if (foundIds) {

++             m_logger->log(

++                     u"Cannot defer property assignment to \"%1\". Assigning an id to an object or one of its sub-objects bound to a deferred property will make the assignment immediate."_s

++                             .arg(propertyName),

++                     qmlDeferredPropertyId, uiob->firstSourceLocation());

++         }

++     }

++

++     if (checkCustomParser(m_currentScope)) {

++         // These warnings do not apply for custom parsers and their children and need to be handled

++         // on a case by case basis

++     } else {

++         m_pendingPropertyObjectBindings

++                 << PendingPropertyObjectBinding { m_currentScope, childScope, propertyName,

++                                                   uiob->firstSourceLocation(), uiob->hasOnToken };

++

++         QQmlJSMetaPropertyBinding binding(uiob->firstSourceLocation(), propertyName);

++         if (uiob->hasOnToken) {

++             if (childScope->hasInterface(u"QQmlPropertyValueInterceptor"_s)) {

++                 binding.setInterceptor(QQmlJSUtils::getScopeName(childScope, QQmlSA::ScopeType::QMLScope),

++                                        QQmlJSScope::ConstPtr(childScope));

++             } else { // if (childScope->hasInterface(u"QQmlPropertyValueSource"_s))

++                 binding.setValueSource(QQmlJSUtils::getScopeName(childScope, QQmlSA::ScopeType::QMLScope),

++                                        QQmlJSScope::ConstPtr(childScope));

++             }

++         } else {

++             binding.setObject(QQmlJSUtils::getScopeName(childScope, QQmlSA::ScopeType::QMLScope),

++                               QQmlJSScope::ConstPtr(childScope));

++         }

++         m_bindings.append(UnfinishedBinding { m_currentScope, [=]() { return binding; } });

++     }

++

++     for (int i = 0; i < scopesEnteredCounter; ++i)

++         leaveEnvironment();

++ }

++

++ bool QQmlJSImportVisitor::visit(ExportDeclaration *)

++ {

++     Q_ASSERT(rootScopeIsValid());

++     Q_ASSERT(m_exportedRootScope != m_globalScope);

++     Q_ASSERT(m_currentScope == m_globalScope);

++     m_currentScope = m_exportedRootScope;

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(ExportDeclaration *)

++ {

++     Q_ASSERT(rootScopeIsValid());

++     m_currentScope = m_exportedRootScope->parentScope();

++     Q_ASSERT(m_currentScope == m_globalScope);

++ }

++

++ bool QQmlJSImportVisitor::visit(ESModule *module)

++ {

++     Q_ASSERT(!rootScopeIsValid());

++     enterRootScope(QQmlSA::ScopeType::JSLexicalScope, QStringLiteral("module"),

++                    module->firstSourceLocation());

++     m_currentScope->setIsScript(true);

++     importBaseModules();

++     leaveEnvironment();

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(ESModule *)

++ {

++     QQmlJSScope::resolveTypes(m_exportedRootScope, m_rootScopeImports.contextualTypes(),

++                               usedTypes());

++ }

++

++ bool QQmlJSImportVisitor::visit(Program *program)

++ {

++     Q_ASSERT(m_globalScope == m_currentScope);

++     Q_ASSERT(!rootScopeIsValid());

++     enterRootScope(QQmlSA::ScopeType::JSFunctionScope, u"script"_s, program->firstSourceLocation());

++     m_exportedRootScope->setIsScript(true);

++     importBaseModules();

++     return true;

++ }

++

++ void QQmlJSImportVisitor::endVisit(Program *)

++ {

++     QQmlJSScope::resolveTypes(m_exportedRootScope, m_rootScopeImports.contextualTypes(),

++                               usedTypes());

++ }

++

++ bool QQmlJSImportVisitor::visit(QQmlJS::AST::PatternElement *element)

++ {

++     // Handles variable declarations such as var x = [1,2,3].

++     if (element->isVariableDeclaration()) {

++         QQmlJS::AST::BoundNames names;

++         element->boundNames(&names);

++         for (const auto &name : std::as_const(names)) {

++             std::optional<QString> typeName;

++             if (TypeAnnotation *annotation = name.typeAnnotation.data())

++                 if (Type *type = annotation->type)

++                     typeName = type->toString();

++             using Kind = QQmlJSScope::JavaScriptIdentifier::Kind;

++             const Kind kind = (element->scope == QQmlJS::AST::VariableScope::Var)

++                     ? Kind::FunctionScoped

++                     : Kind::LexicalScoped;

++             const QString variableName = name.id;

++             if (kind == Kind::LexicalScoped) {

++                 const QQmlJS::SourceLocation location = element->firstSourceLocation();

++                 if (auto previousDeclaration = m_currentScope->ownJSIdentifier(variableName)) {

++                     m_logger->log("Identifier '%1' has already been declared"_L1.arg(variableName), qmlSyntax,

++                                   location);

++                     m_logger->log("Note: previous declaration of '%1' here"_L1.arg(variableName), qmlSyntax,

++                                   previousDeclaration->location);

++                 }

++             }

++             const bool isConstVariable = element->scope == QQmlJS::AST::VariableScope::Const;

++             const bool couldInsert = safeInsertJSIdentifier(m_currentScope,

++                     name.id,

++                     { (element->scope == QQmlJS::AST::VariableScope::Var)

++                               ? QQmlJSScope::JavaScriptIdentifier::FunctionScoped

++                               : QQmlJSScope::JavaScriptIdentifier::LexicalScoped,

++                       name.location, typeName,

++                       isConstVariable});

++             if (!couldInsert)

++                 break;

++         }

++     }

++

++     return true;

++ }

++

++ bool QQmlJSImportVisitor::visit(IfStatement *statement)

++ {

++     if (BinaryExpression *binary = cast<BinaryExpression *>(statement->expression)) {

++         if (binary->op == QSOperator::Assign) {

++             m_logger->log(

++                     "Assignment in condition: did you mean to use \"===\" or \"==\" instead of \"=\"?"_L1,

++                     qmlAssignmentInCondition, binary->operatorToken);

++         }

++     }

++     return true;

++ }

++

++ QT_END_NAMESPACE

Revision control