qt/qtdeclarative/src/qmlcompiler/qqmljstyperesolver.cpp

Revision control

++ // Copyright (C) 2021 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 "qqmljstyperesolver_p.h"
++
++ #include "qqmljsimporter_p.h"
++ #include "qqmljsimportvisitor_p.h"
++ #include "qqmljslogger_p.h"
++ #include "qqmljsutils_p.h"
++ #include <private/qv4value_p.h>
++
++ #include <private/qduplicatetracker_p.h>
++
++ #include <QtCore/qloggingcategory.h>
++ #include <QtCore/qtyperevision.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ Q_STATIC_LOGGING_CATEGORY(lcTypeResolver, "qt.qml.compiler.typeresolver", QtInfoMsg);
++
++ static inline void assertExtension(const QQmlJSScope::ConstPtr &type, QLatin1String extension)
++ {
++ Q_ASSERT(type);
++ Q_ASSERT(type->extensionType().scope->internalName() == extension);
++ Q_ASSERT(type->extensionIsJavaScript());
++ }
++
++ QQmlJSTypeResolver::QQmlJSTypeResolver(QQmlJSImporter *importer)
++ : m_pool(std::make_unique<QQmlJSRegisterContentPool>())
++ , m_imports(importer->builtinInternalNames())
++ , m_importer(importer)
++ {
++ const QQmlJSImporter::ImportedTypes &builtinTypes = m_imports;
++
++ m_voidType = builtinTypes.type(u"void"_s).scope;
++ assertExtension(m_voidType, "undefined"_L1);
++
++ m_nullType = builtinTypes.type(u"std::nullptr_t"_s).scope;
++ Q_ASSERT(m_nullType);
++
++ m_realType = builtinTypes.type(u"double"_s).scope;
++ assertExtension(m_realType, "Number"_L1);
++
++ m_floatType = builtinTypes.type(u"float"_s).scope;
++ assertExtension(m_floatType, "Number"_L1);
++
++ m_int8Type = builtinTypes.type(u"qint8"_s).scope;
++ assertExtension(m_int8Type, "Number"_L1);
++
++ m_uint8Type = builtinTypes.type(u"quint8"_s).scope;
++ assertExtension(m_uint8Type, "Number"_L1);
++
++ m_int16Type = builtinTypes.type(u"short"_s).scope;
++ assertExtension(m_int16Type, "Number"_L1);
++
++ m_uint16Type = builtinTypes.type(u"ushort"_s).scope;
++ assertExtension(m_uint16Type, "Number"_L1);
++
++ m_int32Type = builtinTypes.type(u"int"_s).scope;
++ assertExtension(m_int32Type, "Number"_L1);
++
++ m_uint32Type = builtinTypes.type(u"uint"_s).scope;
++ assertExtension(m_uint32Type, "Number"_L1);
++
++ m_int64Type = builtinTypes.type(u"qlonglong"_s).scope;
++ Q_ASSERT(m_int64Type);
++
++ m_uint64Type = builtinTypes.type(u"qulonglong"_s).scope;
++ Q_ASSERT(m_uint64Type);
++
++ m_sizeType = builtinTypes.type(u"qsizetype"_s).scope;
++ assertExtension(m_sizeType, "Number"_L1);
++
++ // qsizetype is either a 32bit or a 64bit signed integer. We don't want to special-case it.
++ Q_ASSERT(m_sizeType == m_int32Type || m_sizeType == m_int64Type);
++
++ m_boolType = builtinTypes.type(u"bool"_s).scope;
++ assertExtension(m_boolType, "Boolean"_L1);
++
++ m_stringType = builtinTypes.type(u"QString"_s).scope;
++ assertExtension(m_stringType, "String"_L1);
++
++ m_stringListType = builtinTypes.type(u"QStringList"_s).scope;
++ assertExtension(m_stringListType, "Array"_L1);
++
++ m_byteArrayType = builtinTypes.type(u"QByteArray"_s).scope;
++ assertExtension(m_byteArrayType, "ArrayBuffer"_L1);
++
++ m_urlType = builtinTypes.type(u"QUrl"_s).scope;
++ assertExtension(m_urlType, "URL"_L1);
++
++ m_dateTimeType = builtinTypes.type(u"QDateTime"_s).scope;
++ assertExtension(m_dateTimeType, "Date"_L1);
++
++ m_dateType = builtinTypes.type(u"QDate"_s).scope;
++ Q_ASSERT(m_dateType);
++
++ m_timeType = builtinTypes.type(u"QTime"_s).scope;
++ Q_ASSERT(m_timeType);
++
++ m_regexpType = builtinTypes.type(u"QRegularExpression"_s).scope;
++ Q_ASSERT(m_regexpType);
++
++ m_variantListType = builtinTypes.type(u"QVariantList"_s).scope;
++ assertExtension(m_variantListType, "Array"_L1);
++
++ m_variantMapType = builtinTypes.type(u"QVariantMap"_s).scope;
++ Q_ASSERT(m_variantMapType);
++ m_varType = builtinTypes.type(u"QVariant"_s).scope;
++ Q_ASSERT(m_varType);
++
++ m_qmlPropertyMapType = builtinTypes.type(u"QQmlPropertyMap"_s).scope;
++ Q_ASSERT(m_qmlPropertyMapType);
++
++ m_jsValueType = builtinTypes.type(u"QJSValue"_s).scope;
++ Q_ASSERT(m_jsValueType);
++
++ m_qObjectType = builtinTypes.type(u"QObject"_s).scope;
++ assertExtension(m_qObjectType, "Object"_L1);
++
++ m_qObjectListType = builtinTypes.type(u"QObjectList"_s).scope;
++ assertExtension(m_qObjectListType, "Array"_L1);
++
++ m_qQmlScriptStringType = builtinTypes.type(u"QQmlScriptString"_s).scope;
++ Q_ASSERT(m_qQmlScriptStringType);
++
++ m_functionType = builtinTypes.type(u"function"_s).scope;
++ Q_ASSERT(m_functionType);
++
++ m_numberPrototype = builtinTypes.type(u"NumberPrototype"_s).scope;
++ Q_ASSERT(m_numberPrototype);
++
++ m_arrayPrototype = builtinTypes.type(u"ArrayPrototype"_s).scope;
++ Q_ASSERT(m_arrayPrototype);
++
++ m_listPropertyType = m_qObjectType->listType();
++ Q_ASSERT(m_listPropertyType->internalName() == u"QQmlListProperty<QObject>"_s);
++ Q_ASSERT(m_listPropertyType->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence);
++ Q_ASSERT(m_listPropertyType->elementTypeName() == u"QObject"_s);
++ assertExtension(m_listPropertyType, "Array"_L1);
++
++ QQmlJSScope::Ptr emptyType = QQmlJSScope::create();
++ emptyType->setAccessSemantics(QQmlJSScope::AccessSemantics::None);
++ m_emptyType = emptyType;
++
++ QQmlJSScope::Ptr jsPrimitiveType = QQmlJSScope::create();
++ jsPrimitiveType->setInternalName(u"QJSPrimitiveValue"_s);
++ jsPrimitiveType->setFilePath(u"qjsprimitivevalue.h"_s);
++ jsPrimitiveType->setAccessSemantics(QQmlJSScope::AccessSemantics::Value);
++ m_jsPrimitiveType = jsPrimitiveType;
++
++ QQmlJSScope::Ptr metaObjectType = QQmlJSScope::create();
++ metaObjectType->setInternalName(u"const QMetaObject"_s);
++ metaObjectType->setFilePath(u"qmetaobject.h"_s);
++ metaObjectType->setAccessSemantics(QQmlJSScope::AccessSemantics::Reference);
++ m_metaObjectType = metaObjectType;
++
++ m_jsGlobalObject = importer->jsGlobalObject();
++
++ QQmlJSScope::Ptr forInIteratorPtr = QQmlJSScope::create();
++ forInIteratorPtr->setAccessSemantics(QQmlJSScope::AccessSemantics::Value);
++ forInIteratorPtr->setFilePath(u"qjslist.h"_s);
++ forInIteratorPtr->setInternalName(u"QJSListForInIterator::Ptr"_s);
++ m_forInIteratorPtr = forInIteratorPtr;
++
++ QQmlJSScope::Ptr forOfIteratorPtr = QQmlJSScope::create();
++ forOfIteratorPtr->setAccessSemantics(QQmlJSScope::AccessSemantics::Value);
++ forOfIteratorPtr->setFilePath(u"qjslist.h"_s);
++ forOfIteratorPtr->setInternalName(u"QJSListForOfIterator::Ptr"_s);
++ m_forOfIteratorPtr = forOfIteratorPtr;
++
++ // We use this as scope type quite often, and it should always be the same scope type.
++ m_jsGlobalObjectContent = m_pool->createType(
++ m_jsGlobalObject, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::ScopeObject);
++ }
++
++ /*!
++ \internal
++
++ Initializes the type resolver. As part of that initialization, makes \a
++ visitor traverse the program when given.
++ */
++ void QQmlJSTypeResolver::init(QQmlJSImportVisitor *visitor, QQmlJS::AST::Node *program)
++ {
++ m_logger = visitor->logger();
++
++ m_objectsById.clear();
++ m_objectsByLocation.clear();
++ m_imports.clear();
++ m_signalHandlers.clear();
++ m_mergeCache.clear();
++
++ if (program)
++ program->accept(visitor);
++
++ m_objectsById = visitor->addressableScopes();
++ m_objectsByLocation = visitor->scopesBylocation();
++ m_signalHandlers = visitor->signalHandlers();
++ m_imports = visitor->imports();
++ m_seenModuleQualifiers = visitor->seenModuleQualifiers();
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::mathObject() const
++ {
++ return jsGlobalObject()->property(u"Math"_s).type();
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::consoleObject() const
++ {
++ return jsGlobalObject()->property(u"console"_s).type();
++ }
++
++ QQmlJSScope::ConstPtr
++ QQmlJSTypeResolver::scopeForLocation(const QV4::CompiledData::Location &location) const
++ {
++ // #if required for standalone DOM compilation against Qt 6.2
++ qCDebug(lcTypeResolver()).nospace()
++ << "looking for object at " << location.line() << ':' << location.column();
++ return m_objectsByLocation[location];
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::typeFromAST(QQmlJS::AST::Type *type) const
++ {
++ const QString typeId = QmlIR::IRBuilder::asString(type->typeId);
++ if (!type->typeArgument)
++ return m_imports.type(typeId).scope;
++ if (typeId == u"list"_s) {
++ if (const QQmlJSScope::ConstPtr typeArgument = typeForName(type->typeArgument->toString()))
++ return typeArgument->listType();
++ }
++ return QQmlJSScope::ConstPtr();
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::typeForConst(QV4::ReturnedValue rv) const
++ {
++ QV4::Value value = QV4::Value::fromReturnedValue(rv);
++ if (value.isUndefined())
++ return voidType();
++
++ if (value.isInt32())
++ return int32Type();
++
++ if (value.isBoolean())
++ return boolType();
++
++ if (value.isDouble())
++ return realType();
++
++ if (value.isNull())
++ return nullType();
++
++ if (value.isEmpty())
++ return emptyType();
++
++ return {};
++ }
++
++ QQmlJSRegisterContent
++ QQmlJSTypeResolver::typeForBinaryOperation(QSOperator::Op oper, QQmlJSRegisterContent left,
++ QQmlJSRegisterContent right) const
++ {
++ Q_ASSERT(left.isValid());
++ Q_ASSERT(right.isValid());
++
++ switch (oper) {
++ case QSOperator::Op::Equal:
++ case QSOperator::Op::NotEqual:
++ case QSOperator::Op::StrictEqual:
++ case QSOperator::Op::StrictNotEqual:
++ case QSOperator::Op::Lt:
++ case QSOperator::Op::Gt:
++ case QSOperator::Op::Ge:
++ case QSOperator::Op::In:
++ case QSOperator::Op::Le:
++ return operationType(boolType());
++ case QSOperator::Op::BitAnd:
++ case QSOperator::Op::BitOr:
++ case QSOperator::Op::BitXor:
++ case QSOperator::Op::LShift:
++ case QSOperator::Op::RShift:
++ return operationType(int32Type());
++ case QSOperator::Op::URShift:
++ return operationType(uint32Type());
++ case QSOperator::Op::Add: {
++ const auto leftContents = left.containedType();
++ const auto rightContents = right.containedType();
++ if (leftContents == stringType() || rightContents == stringType())
++ return operationType(stringType());
++
++ const QQmlJSScope::ConstPtr result = merge(leftContents, rightContents);
++ if (result == boolType())
++ return operationType(int32Type());
++ if (isNumeric(result))
++ return operationType(realType());
++
++ return operationType(jsPrimitiveType());
++ }
++ case QSOperator::Op::Sub:
++ case QSOperator::Op::Mul:
++ case QSOperator::Op::Exp: {
++ const QQmlJSScope::ConstPtr result = merge(left.containedType(), right.containedType());
++ return operationType(result == boolType() ? int32Type() : realType());
++ }
++ case QSOperator::Op::Div:
++ case QSOperator::Op::Mod:
++ return operationType(realType());
++ case QSOperator::Op::As:
++ return operationType(right.containedType());
++ default:
++ break;
++ }
++
++ return operationType(merge(left.containedType(), right.containedType()));
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::typeForArithmeticUnaryOperation(
++ UnaryOperator op, QQmlJSRegisterContent operand) const
++ {
++ switch (op) {
++ case UnaryOperator::Not:
++ return operationType(boolType());
++ case UnaryOperator::Complement:
++ return operationType(int32Type());
++ case UnaryOperator::Plus:
++ if (isIntegral(operand))
++ return operationType(operand.containedType());
++ Q_FALLTHROUGH();
++ default:
++ if (operand.containedType() == boolType())
++ return operationType(int32Type());
++ break;
++ }
++
++ return operationType(realType());
++ }
++
++ bool QQmlJSTypeResolver::isPrimitive(QQmlJSRegisterContent type) const
++ {
++ return isPrimitive(type.containedType());
++ }
++
++ bool QQmlJSTypeResolver::isNumeric(QQmlJSRegisterContent type) const
++ {
++ return isNumeric(type.containedType());
++ }
++
++ bool QQmlJSTypeResolver::isIntegral(QQmlJSRegisterContent type) const
++ {
++ return isIntegral(type.containedType());
++ }
++
++ bool QQmlJSTypeResolver::isIntegral(const QQmlJSScope::ConstPtr &type) const
++ {
++ return isSignedInteger(type) || isUnsignedInteger(type);
++ }
++
++ bool QQmlJSTypeResolver::isPrimitive(const QQmlJSScope::ConstPtr &type) const
++ {
++ return (isNumeric(type) && type != m_int64Type && type != m_uint64Type)
++ || type == m_boolType || type == m_voidType || type == m_nullType
++ || type == m_stringType || type == m_jsPrimitiveType;
++ }
++
++ bool QQmlJSTypeResolver::isNumeric(const QQmlJSScope::ConstPtr &type) const
++ {
++ if (!type) // should this be a precondition instead?
++ return false;
++
++ if (type->scopeType() == QQmlJSScope::ScopeType::EnumScope)
++ return true;
++
++ if (type == m_realType)
++ return true;
++ if (type == m_floatType)
++ return true;
++ if (type == m_int8Type)
++ return true;
++ if (type == m_uint8Type)
++ return true;
++ if (type == m_int16Type)
++ return true;
++ if (type == m_uint16Type)
++ return true;
++ if (type == m_int32Type)
++ return true;
++ if (type == m_uint32Type)
++ return true;
++ if (type == m_int64Type)
++ return true;
++ if (type == m_uint64Type)
++ return true;
++ // sizetype is covered by one of the above cases (int32 or int64)
++ // booleans are not numeric
++
++ // the number prototype is numeric
++ if (type == m_numberPrototype)
++ return true;
++
++ // and types directly inheriting from it, notably number, are also
++ // numeric
++ if (type->baseType() == m_numberPrototype)
++ return true;
++
++ // it isn't possible (for users) to derive from m_numberPrototpye,
++ // so we know the list above is exhaustive / we don't need to go up
++ // further in the inheritance chain
++
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::isSignedInteger(const QQmlJSScope::ConstPtr &type) const
++ {
++ return type == m_int8Type || type == m_int16Type
++ || type == m_int32Type || type == m_int64Type;
++ }
++
++ bool QQmlJSTypeResolver::isUnsignedInteger(const QQmlJSScope::ConstPtr &type) const
++ {
++ return type == m_uint8Type || type == m_uint16Type
++ || type == m_uint32Type || type == m_uint64Type;
++ }
++
++ bool QQmlJSTypeResolver::isNativeArrayIndex(const QQmlJSScope::ConstPtr &type) const
++ {
++ return type == m_uint8Type || type == m_int8Type || type == m_uint16Type || type == m_int16Type
++ || type == m_uint32Type || type == m_int32Type;
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::containedTypeForName(const QString &name) const
++ {
++ QQmlJSScope::ConstPtr type = typeForName(name);
++
++ if (!type || type->isSingleton() || type->isScript())
++ return type;
++
++ switch (type->accessSemantics()) {
++ case QQmlJSScope::AccessSemantics::Reference:
++ if (const auto attached = type->attachedType())
++ return genericType(attached) ? attached : QQmlJSScope::ConstPtr();
++ return metaObjectType();
++ case QQmlJSScope::AccessSemantics::None:
++ return metaObjectType();
++ case QQmlJSScope::AccessSemantics::Sequence:
++ case QQmlJSScope::AccessSemantics::Value:
++ return canAddressValueTypes() ? metaObjectType() : QQmlJSScope::ConstPtr();
++ }
++
++ Q_UNREACHABLE_RETURN(QQmlJSScope::ConstPtr());
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::registerContentForName(
++ const QString &name, QQmlJSRegisterContent scopeType) const
++ {
++ QQmlJSScope::ConstPtr type = typeForName(name);
++ if (!type)
++ return QQmlJSRegisterContent();
++
++ if (type->isSingleton()) {
++ return m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::Singleton, scopeType);
++ }
++
++ if (type->isScript()) {
++ return m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::Script, scopeType);
++ }
++
++ const QQmlJSRegisterContent namedType = m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::TypeByName,
++ scopeType);
++
++ if (const auto attached = type->attachedType()) {
++ if (!genericType(attached)) {
++ m_logger->log(u"Cannot resolve generic base of attached %1"_s.arg(
++ attached->internalName()),
++ qmlCompiler, attached->sourceLocation());
++ return {};
++ } else if (type->accessSemantics() != QQmlJSScope::AccessSemantics::Reference) {
++ m_logger->log(u"Cannot retrieve attached object for non-reference type %1"_s.arg(
++ type->internalName()),
++ qmlCompiler, type->sourceLocation());
++ return {};
++ } else {
++ // We don't know yet whether we need the attached or the plain object. In direct
++ // mode, we will figure this out using the scope type and access any enums of the
++ // plain type directly. In indirect mode, we can use enum lookups.
++ return m_pool->createType(
++ attached, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::Attachment, namedType);
++ }
++ }
++
++ switch (type->accessSemantics()) {
++ case QQmlJSScope::AccessSemantics::None:
++ case QQmlJSScope::AccessSemantics::Reference:
++ // A plain reference to a non-singleton, non-attached type.
++ // We may still need the plain type reference for enum lookups,
++ // Store it as QMetaObject.
++ // This only works with namespaces and object types.
++ return m_pool->createType(
++ metaObjectType(), QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::MetaType, namedType);
++ case QQmlJSScope::AccessSemantics::Sequence:
++ case QQmlJSScope::AccessSemantics::Value:
++ if (scopeType.isImportNamespace() || canAddressValueTypes()) {
++ return m_pool->createType(
++ metaObjectType(), QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::MetaType, namedType);
++ }
++ // Else this is not actually a type reference. You cannot get the metaobject
++ // of a value type in QML and sequences don't even have metaobjects.
++ break;
++ }
++
++ return QQmlJSRegisterContent();
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::original(QQmlJSRegisterContent type) const
++ {
++ QQmlJSRegisterContent result = type.original();
++ return result.isNull() ? type : result;
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::originalContainedType(
++ QQmlJSRegisterContent container) const
++ {
++ return original(container).containedType();
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::shadowed(QQmlJSRegisterContent type) const
++ {
++ QQmlJSRegisterContent result = type.shadowed();
++ return result.isNull() ? type : result;
++ }
++
++ bool QQmlJSTypeResolver::adjustTrackedType(
++ QQmlJSRegisterContent tracked, const QQmlJSScope::ConstPtr &conversion) const
++ {
++ if (m_cloneMode == QQmlJSTypeResolver::DoNotCloneTypes)
++ return true;
++
++ QQmlJSScope::ConstPtr contained = tracked.containedType();
++ QQmlJSScope::ConstPtr result = conversion;
++
++ // Do not adjust to the JavaScript extension of the original type. Rather keep the original
++ // type in that case.
++ QQmlJSUtils::searchBaseAndExtensionTypes(
++ contained, [&](const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ExtensionKind kind) {
++ if (kind != QQmlJSScope::ExtensionJavaScript || scope != result)
++ return false;
++ result = contained;
++ return true;
++ });
++
++
++ // If we cannot convert to the new type without the help of e.g. lookupResultMetaType(),
++ // we better not change the type.
++ if (!canPrimitivelyConvertFromTo(contained, result)
++ && !canPopulate(result, contained, nullptr)
++ && !selectConstructor(result, contained, nullptr).isValid()) {
++ return false;
++ }
++
++ m_pool->adjustType(tracked, result);
++ return true;
++ }
++
++ bool QQmlJSTypeResolver::adjustTrackedType(
++ QQmlJSRegisterContent tracked, QQmlJSRegisterContent conversion) const
++ {
++ return adjustTrackedType(tracked, conversion.containedType());
++ }
++
++ bool QQmlJSTypeResolver::adjustTrackedType(
++ QQmlJSRegisterContent tracked, const QList<QQmlJSRegisterContent> &conversions) const
++ {
++ if (m_cloneMode == QQmlJSTypeResolver::DoNotCloneTypes)
++ return true;
++
++ QQmlJSScope::ConstPtr result;
++ for (QQmlJSRegisterContent type : conversions)
++ result = merge(type.containedType(), result);
++
++ return adjustTrackedType(tracked, result);
++ }
++
++ void QQmlJSTypeResolver::adjustOriginalType(
++ QQmlJSRegisterContent tracked, const QQmlJSScope::ConstPtr &conversion) const
++ {
++ if (m_cloneMode == QQmlJSTypeResolver::DoNotCloneTypes)
++ return;
++
++ m_pool->generalizeType(tracked, conversion);
++ }
++
++ void QQmlJSTypeResolver::generalizeType(QQmlJSRegisterContent type) const
++ {
++ if (m_cloneMode == QQmlJSTypeResolver::DoNotCloneTypes)
++ return;
++
++ for (QQmlJSRegisterContent orig = type; !orig.isNull(); orig = orig.original()) {
++ if (!orig.shadowed().isValid())
++ m_pool->generalizeType(orig, genericType(orig.containedType()));
++ }
++ }
++
++ bool QQmlJSTypeResolver::canConvertFromTo(const QQmlJSScope::ConstPtr &from,
++ const QQmlJSScope::ConstPtr &to) const
++ {
++ if (canPrimitivelyConvertFromTo(from, to)
++ || canPopulate(to, from, nullptr)
++ || selectConstructor(to, from, nullptr).isValid()) {
++ return true;
++ }
++
++ // ### need a generic solution for custom cpp types:
++ // if (from->m_hasBoolOverload && equals(to, boolType))
++ // return true;
++
++ // All of these types have QString conversions that require a certain format
++ // TODO: Actually verify these strings or deprecate them.
++ // Some of those type are builtins or should be builtins. We should add code for them
++ // in QQmlJSCodeGenerator::conversion().
++ if (from == m_stringType && !to.isNull()) {
++ const QString toTypeName = to->internalName();
++ if (toTypeName == u"QPoint"_s || toTypeName == u"QPointF"_s
++ || toTypeName == u"QSize"_s || toTypeName == u"QSizeF"_s
++ || toTypeName == u"QRect"_s || toTypeName == u"QRectF"_s) {
++ return true;
++ }
++ }
++
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::canConvertFromTo(QQmlJSRegisterContent from,
++ QQmlJSRegisterContent to) const
++ {
++ return canConvertFromTo(from.containedType(), to.containedType());
++ }
++
++ static QQmlJSRegisterContent::ContentVariant mergeVariants(QQmlJSRegisterContent::ContentVariant a,
++ QQmlJSRegisterContent::ContentVariant b)
++ {
++ return (a == b) ? a : QQmlJSRegisterContent::Unknown;
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::merge(
++ QQmlJSRegisterContent a, QQmlJSRegisterContent b) const
++ {
++ Q_ASSERT(a != b);
++
++ // Both mergeScopes() calls below recurse into this function. See m_mergeCache.
++ const RegisterPair key(a, b);
++ if (const auto it = m_mergeCache.constFind(key); it != m_mergeCache.constEnd())
++ return m_pool->clone(*it);
++
++ // We cannot easily provide an operator< for QQmlJSRegisterContent.
++ // Therefore we use qHash and operator== here to deduplicate. That's somewhat inefficient.
++ QSet<QQmlJSRegisterContent> origins;
++
++ QQmlJSRegisterContent aResultScope;
++ if (a.isConversion()) {
++ const auto &aOrigins = a.conversionOrigins();
++ for (const auto &aOrigin : aOrigins)
++ origins.insert(aOrigin);
++ aResultScope = a.conversionResultScope();
++ } else {
++ origins.insert(a);
++ aResultScope = a.scope();
++ }
++
++ QQmlJSRegisterContent bResultScope;
++ if (b.isConversion()) {
++ const auto &bOrigins = b.conversionOrigins();
++ for (const auto &bOrigin : bOrigins)
++ origins.insert(bOrigin);
++ bResultScope = b.conversionResultScope();
++ } else {
++ origins.insert(b);
++ bResultScope = b.scope();
++ }
++
++ const auto mergeScopes = [&](QQmlJSRegisterContent a, QQmlJSRegisterContent b) {
++ // If they are the same, we don't want to re-track them.
++ // We want the repetition on type mismatches to converge.
++ return (a == b) ? a : merge(a, b);
++ };
++
++ const QQmlJSRegisterContent merged = m_pool->createConversion(
++ origins.values(),
++ merge(a.containedType(), b.containedType()),
++ mergeScopes(aResultScope, bResultScope),
++ mergeVariants(a.variant(), b.variant()),
++ mergeScopes(a.scope(), b.scope()));
++
++ m_mergeCache.insert(key, m_pool->clone(merged));
++ return merged;
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::merge(const QQmlJSScope::ConstPtr &a,
++ const QQmlJSScope::ConstPtr &b) const
++ {
++ if (a.isNull())
++ return b;
++
++ if (b.isNull())
++ return a;
++
++ const auto baseOrExtension
++ = [](const QQmlJSScope::ConstPtr &a, const QQmlJSScope::ConstPtr &b) {
++ QQmlJSScope::ConstPtr found;
++ QQmlJSUtils::searchBaseAndExtensionTypes(
++ a, [&](const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ExtensionKind kind) {
++ switch (kind) {
++ case QQmlJSScope::NotExtension:
++ // If b inherits scope, then scope is a common base type of a and b
++ if (b->inherits(scope)) {
++ found = scope;
++ return true;
++ }
++ break;
++ case QQmlJSScope::ExtensionJavaScript:
++ // Merging a type with its JavaScript extension produces the type.
++ // Giving the JavaScript extension as type to be read means we expect any type
++ // that fulfills the given JavaScript interface
++ if (scope == b) {
++ found = a;
++ return true;
++ }
++ break;
++ case QQmlJSScope::ExtensionType:
++ case QQmlJSScope::ExtensionNamespace:
++ break;
++ }
++ return false;
++ });
++ return found;
++ };
++
++ if (a == b)
++ return a;
++
++ if (a == jsValueType() || a == varType())
++ return a;
++ if (b == jsValueType() || b == varType())
++ return b;
++
++ const auto isInt32Compatible = [&](const QQmlJSScope::ConstPtr &type) {
++ return (isIntegral(type)
++ && type != uint32Type()
++ && type != int64Type()
++ && type != uint64Type())
++ || type == boolType();
++ };
++
++ if (isInt32Compatible(a) && isInt32Compatible(b))
++ return int32Type();
++
++ const auto isUInt32Compatible = [&](const QQmlJSScope::ConstPtr &type) {
++ return (isUnsignedInteger(type) && type != uint64Type()) || type == boolType();
++ };
++
++ if (isUInt32Compatible(a) && isUInt32Compatible(b))
++ return uint32Type();
++
++ if (isNumeric(a) && isNumeric(b))
++ return realType();
++
++ if (isPrimitive(a) && isPrimitive(b))
++ return jsPrimitiveType();
++
++ if (const auto base = baseOrExtension(a, b))
++ return base;
++
++ if (const auto base = baseOrExtension(b, a))
++ return base;
++
++ if ((a == nullType() || a == boolType()) && b->isReferenceType())
++ return b;
++
++ if ((b == nullType() || b == boolType()) && a->isReferenceType())
++ return a;
++
++ return varType();
++ }
++
++ bool QQmlJSTypeResolver::canHold(
++ const QQmlJSScope::ConstPtr &container, const QQmlJSScope::ConstPtr &contained) const
++ {
++ if (container == contained || container == m_varType || container == m_jsValueType)
++ return true;
++
++ if (container == m_jsPrimitiveType)
++ return isPrimitive(contained);
++
++ if (container == m_variantListType)
++ return contained->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence;
++
++ if (container == m_qObjectListType || container == m_listPropertyType) {
++ if (contained->accessSemantics() != QQmlJSScope::AccessSemantics::Sequence)
++ return false;
++ if (QQmlJSScope::ConstPtr element = contained->elementType())
++ return element->isReferenceType();
++ return false;
++ }
++
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(
++ container, [&](const QQmlJSScope::ConstPtr &base) {
++ return base == contained;
++ })) {
++ return true;
++ }
++
++ if (container->isReferenceType()) {
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(
++ contained, [&](const QQmlJSScope::ConstPtr &base) {
++ return base == container;
++ })) {
++ return true;
++ }
++ }
++
++ return false;
++ }
++
++
++ bool QQmlJSTypeResolver::canHoldUndefined(QQmlJSRegisterContent content) const
++ {
++ const auto canBeUndefined = [this](const QQmlJSScope::ConstPtr &type) {
++ return type == m_voidType || type == m_varType
++ || type == m_jsValueType || type == m_jsPrimitiveType;
++ };
++
++ if (!canBeUndefined(content.containedType()))
++ return false;
++
++ if (!content.isConversion())
++ return true;
++
++ const auto &origins = content.conversionOrigins();
++ for (const auto &origin : origins) {
++ if (canBeUndefined(originalContainedType(origin)))
++ return true;
++ }
++
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::isOptionalType(QQmlJSRegisterContent content) const
++ {
++ if (!content.isConversion())
++ return false;
++
++ const auto &origins = content.conversionOrigins();
++ if (origins.length() != 2)
++ return false;
++
++ // Conversion origins are always adjusted to the conversion result. None of them will be void.
++ // Therefore, retrieve the originals first.
++
++ return original(origins[0]).contains(m_voidType) || original(origins[1]).contains(m_voidType);
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::extractNonVoidFromOptionalType(
++ QQmlJSRegisterContent content) const
++ {
++ if (!isOptionalType(content))
++ return QQmlJSRegisterContent();
++
++ // Conversion origins are always adjusted to the conversion result. None of them will be void.
++ // Therefore, retrieve the originals first.
++
++ QList<QQmlJSRegisterContent> origins(content.conversionOrigins());
++ std::transform(origins.cbegin(), origins.cend(), origins.begin(),
++ [this](QQmlJSRegisterContent content) {return original(content);});
++ const auto &constOrigins = origins;
++ const QQmlJSRegisterContent result = constOrigins[0].contains(m_voidType)
++ ? constOrigins[1]
++ : constOrigins[0];
++
++ // The result may still be undefined. You can write "undefined ?? undefined ?? 1"
++ return result;
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::genericType(
++ const QQmlJSScope::ConstPtr &type,
++ ComponentIsGeneric allowComponent) const
++ {
++ if (type->isScript())
++ return m_jsValueType;
++
++ if (type == m_metaObjectType)
++ return m_metaObjectType;
++
++ if (type->accessSemantics() == QQmlJSScope::AccessSemantics::Reference) {
++ QString unresolvedBaseTypeName;
++ for (auto base = type; base;) {
++ // QObject and QQmlComponent are the two required base types.
++ // Any QML type system has to define those, or use the ones from builtins.
++ // As QQmlComponent is derived from QObject, we can restrict ourselves to the latter.
++ // This results in less if'ery when retrieving a QObject* from somewhere and deciding
++ // what it is.
++ if (base->internalName() == u"QObject"_s) {
++ return base;
++ } else if (allowComponent == ComponentIsGeneric::Yes
++ && base->internalName() == u"QQmlComponent"_s) {
++ return base;
++ }
++
++ if (auto baseBase = base->baseType()) {
++ base = baseBase;
++ } else {
++ unresolvedBaseTypeName = base->baseTypeName();
++ break;
++ }
++ }
++
++ // Reference types that are not QObject or QQmlComponent are likely JavaScript objects.
++ // We don't want to deal with those, but m_jsValueType is the best generic option.
++ if (type->filePath().isEmpty())
++ return m_jsValueType;
++
++ m_logger->log(u"Object type %1 is not derived from QObject or QQmlComponent. "
++ "You may need to fully qualify all names in C++ so that moc can see them. "
++ "You may also need to add qt_extract_metatypes(<target containing %2>)."_s
++ .arg(type->internalName(), unresolvedBaseTypeName),
++ qmlCompiler, type->sourceLocation());
++
++ // If it does have a filePath, it's some C++ type which we haven't fully resolved.
++ return m_jsValueType;
++ }
++
++ if (type->isListProperty())
++ return m_listPropertyType;
++
++ if (type->scopeType() == QQmlSA::ScopeType::EnumScope)
++ return type->baseType();
++
++ if (isPrimitive(type)) {
++ // If the filePath is set, the type is storable and we can just return it.
++ if (!type->filePath().isEmpty())
++ return type;
++
++ // If the type is JavaScript's 'number' type, it's not directly storable, but still
++ // primitive. We use C++ 'double' then.
++ if (isNumeric(type))
++ return m_realType;
++
++ // Otherwise we use QJSPrimitiveValue.
++ // TODO: JavaScript's 'string' and 'boolean' could be special-cased here.
++ return m_jsPrimitiveType;
++ }
++
++ for (const QQmlJSScope::ConstPtr &builtin : {
++ m_realType, m_floatType, m_int8Type, m_uint8Type, m_int16Type, m_uint16Type,
++ m_int32Type, m_uint32Type, m_int64Type, m_uint64Type, m_boolType, m_stringType,
++ m_stringListType, m_byteArrayType, m_urlType, m_dateTimeType, m_dateType,
++ m_timeType, m_variantListType, m_variantMapType, m_varType, m_jsValueType,
++ m_jsPrimitiveType, m_listPropertyType, m_qObjectType, m_qObjectListType,
++ m_metaObjectType, m_forInIteratorPtr, m_forOfIteratorPtr }) {
++ if (type == builtin || type == builtin->listType())
++ return type;
++ }
++
++ return m_varType;
++ }
++
++ /*!
++ * \internal
++ * The type of a JavaScript literal value appearing in script code
++ */
++ QQmlJSRegisterContent QQmlJSTypeResolver::literalType(const QQmlJSScope::ConstPtr &type) const
++ {
++ return m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::Literal);
++ }
++
++ /*!
++ * \internal
++ * The type of the result of a JavaScript operation
++ */
++ QQmlJSRegisterContent QQmlJSTypeResolver::operationType(const QQmlJSScope::ConstPtr &type) const
++ {
++ return m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::Operation);
++ }
++
++ /*!
++ * \internal
++ * A type named explicitly, for example in "as"-casts or as function annotation.
++ */
++ QQmlJSRegisterContent QQmlJSTypeResolver::namedType(const QQmlJSScope::ConstPtr &type) const
++ {
++ return m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::TypeByName);
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::syntheticType(const QQmlJSScope::ConstPtr &type) const
++ {
++ return m_pool->createType(
++ type, QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::Unknown);
++ }
++
++ static QQmlJSRegisterContent::ContentVariant scopeContentVariant(QQmlJSScope::ExtensionKind mode,
++ bool isMethod)
++ {
++ switch (mode) {
++ case QQmlJSScope::NotExtension:
++ case QQmlJSScope::ExtensionType:
++ case QQmlJSScope::ExtensionJavaScript:
++ return isMethod
++ ? QQmlJSRegisterContent::Method
++ : QQmlJSRegisterContent::Property;
++ case QQmlJSScope::ExtensionNamespace:
++ break;
++ }
++ Q_UNREACHABLE_RETURN(QQmlJSRegisterContent::Unknown);
++ }
++
++ static bool isRevisionAllowed(int memberRevision, const QQmlJSScope::ConstPtr &scope)
++ {
++ Q_ASSERT(scope->isComposite());
++ const QTypeRevision revision = QTypeRevision::fromEncodedVersion(memberRevision);
++
++ // If the memberRevision is either invalid or 0.0, then everything is allowed.
++ if (!revision.isValid() || revision == QTypeRevision::zero())
++ return true;
++
++ const QTypeRevision typeRevision = QQmlJSScope::nonCompositeBaseRevision(
++ {scope->baseType(), scope->baseTypeRevision()});
++
++ // If the revision is not valid, we haven't found a non-composite base type.
++ // There is nothing we can say about the property then.
++ return typeRevision.isValid() && typeRevision >= revision;
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::resolveParentProperty(
++ const QString &name, const QQmlJSScope::ConstPtr &base,
++ const QQmlJSScope::ConstPtr &propType) const
++ {
++ if (m_parentMode != UseDocumentParent || name != base->parentPropertyName())
++ return propType;
++
++ const QQmlJSScope::ConstPtr baseParent = base->parentScope();
++ if (!baseParent || !baseParent->inherits(propType))
++ return propType;
++
++ const QString defaultPropertyName = baseParent->defaultPropertyName();
++ if (defaultPropertyName.isEmpty()) // no reason to search for bindings
++ return propType;
++
++ const QList<QQmlJSMetaPropertyBinding> defaultPropBindings
++ = baseParent->propertyBindings(defaultPropertyName);
++ for (const QQmlJSMetaPropertyBinding &binding : defaultPropBindings) {
++ if (binding.bindingType() == QQmlSA::BindingType::Object && binding.objectType() == base)
++ return baseParent;
++ }
++
++ return propType;
++ }
++
++ /*!
++ * \internal
++ *
++ * Retrieves the type of whatever \a name signifies in the given \a scope.
++ * \a name can be an ID, a property of the scope, a singleton, an attachment,
++ * a plain type reference or a JavaScript global.
++ *
++ * TODO: The lookup is actually wrong. We cannot really retrieve JavaScript
++ * globals here because any runtime-inserted context property would
++ * override them. We still do because we don't have a better solution for
++ * identifying e.g. the console object, yet.
++ *
++ * \a options tells us whether to consider components as bound. If components
++ * are bound we can retrieve objects identified by ID in outer contexts.
++ *
++ * TODO: This is also wrong because we should alternate scopes and contexts when
++ * traveling the scope/context hierarchy. Currently we have IDs from any
++ * context override all scope properties if components are considered
++ * bound. This is mostly because we don't care about outer scopes at all;
++ * so we cannot determine with certainty whether an ID from a far outer
++ * context is overridden by a property of a near outer scope. To
++ * complicate this further, user context properties can also be inserted
++ * in outer contexts at run time, shadowing names in further removed outer
++ * scopes and contexts. What we need to do is determine where exactly what
++ * kind of property can show up and defend against that with additional
++ * pragmas.
++ *
++ * Note: It probably takes at least 3 nested bound components in one document to
++ * trigger the misbehavior.
++ */
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::scopedType(
++ const QQmlJSScope::ConstPtr &scope, const QString &name,
++ QQmlJSScopesByIdOptions options) const
++ {
++ QQmlJSScopesById::CertainCallback<QQmlJSScope::ConstPtr> identified;
++ if (m_objectsById.possibleScopes(name, scope, options, identified)
++ != QQmlJSScopesById::Success::Yes) {
++ // Could not determine component boundaries
++ return {};
++ }
++
++ if (identified.result) {
++ // Found a definite match
++ return identified.result;
++ }
++
++ if (QQmlJSScope::ConstPtr base = QQmlJSScope::findCurrentQMLScope(scope)) {
++ QQmlJSScope::ConstPtr result;
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(
++ base, [&](const QQmlJSScope::ConstPtr &found, QQmlJSScope::ExtensionKind mode) {
++ if (mode == QQmlJSScope::ExtensionNamespace) // no use for it here
++ return false;
++
++ if (found->hasOwnProperty(name)) {
++ const QQmlJSMetaProperty prop = found->ownProperty(name);
++ if (!isRevisionAllowed(prop.revision(), scope))
++ return false;
++
++ result = resolveParentProperty(name, base, prop.type());
++ return true;
++ }
++
++ if (found->hasOwnMethod(name)) {
++ const auto methods = found->ownMethods(name);
++ for (const auto &method : methods) {
++ if (isRevisionAllowed(method.revision(), scope)) {
++ result = jsValueType();
++ return true;
++ }
++ }
++ }
++
++ return false;
++ })) {
++ return result;
++ }
++ }
++
++ if (QQmlJSScope::ConstPtr result = containedTypeForName(name))
++ return result;
++
++ if (m_jsGlobalObject->hasProperty(name))
++ return m_jsGlobalObject->property(name).type();
++
++ if (m_jsGlobalObject->hasMethod(name))
++ return jsValueType();
++
++ return {};
++ }
++
++ /*!
++ * \internal
++ *
++ * Same as the other scopedType method, but accepts a QQmlJSRegisterContent and
++ * also returns one. This way you not only get the type, but also the content
++ * variant and various meta info.
++ */
++ QQmlJSRegisterContent QQmlJSTypeResolver::scopedType(QQmlJSRegisterContent scope,
++ const QString &name, int lookupIndex,
++ QQmlJSScopesByIdOptions options) const
++ {
++ const QQmlJSScope::ConstPtr contained = scope.containedType();
++
++ QQmlJSScopesById::CertainCallback<QQmlJSScope::ConstPtr> identified;
++ if (m_objectsById.possibleScopes(name, contained, options, identified)
++ != QQmlJSScopesById::Success::Yes) {
++ // Could not determine component boundaries
++ return {};
++ }
++
++ if (identified.result) {
++ // Found a definite match
++ return m_pool->createType(
++ identified.result, lookupIndex, QQmlJSRegisterContent::ObjectById, scope);
++ }
++
++ if (QQmlJSScope::ConstPtr base = QQmlJSScope::findCurrentQMLScope(contained)) {
++ QQmlJSRegisterContent result;
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(
++ base, [&](const QQmlJSScope::ConstPtr &found, QQmlJSScope::ExtensionKind mode) {
++ if (mode == QQmlJSScope::ExtensionNamespace) // no use for it here
++ return false;
++
++ const QQmlJSRegisterContent resultScope = mode == QQmlJSScope::NotExtension
++ ? scope
++ : extensionType(found, scope);
++
++ if (found->hasOwnProperty(name)) {
++ QQmlJSMetaProperty prop = found->ownProperty(name);
++ if (!isRevisionAllowed(prop.revision(), contained))
++ return false;
++
++ prop.setType(resolveParentProperty(name, base, prop.type()));
++ result = m_pool->createProperty(
++ prop, QQmlJSRegisterContent::InvalidLookupIndex, lookupIndex,
++ scopeContentVariant(mode, false), resultScope);
++ return true;
++ }
++
++ if (found->hasOwnMethod(name)) {
++ auto methods = found->ownMethods(name);
++ for (auto it = methods.begin(); it != methods.end();) {
++ if (!isRevisionAllowed(it->revision(), contained))
++ it = methods.erase(it);
++ else
++ ++it;
++ }
++ if (methods.isEmpty())
++ return false;
++ result = m_pool->createMethod(
++ methods, jsValueType(), scopeContentVariant(mode, true), resultScope);
++ return true;
++ }
++
++ // Unqualified enums are not allowed
++ return false;
++ })) {
++ return result;
++ }
++ }
++
++ QQmlJSRegisterContent result = registerContentForName(name, scope);
++
++ if (result.isValid())
++ return result;
++
++ if (m_jsGlobalObject->hasProperty(name)) {
++ return m_pool->createProperty(
++ m_jsGlobalObject->property(name), QQmlJSRegisterContent::InvalidLookupIndex,
++ lookupIndex, QQmlJSRegisterContent::Property, m_jsGlobalObjectContent);
++ } else if (m_jsGlobalObject->hasMethod(name)) {
++ return m_pool->createMethod(
++ m_jsGlobalObject->methods(name), jsValueType(),
++ QQmlJSRegisterContent::Property, m_jsGlobalObjectContent);
++ }
++
++ return {};
++ }
++
++ /*!
++ * \fn QQmlJSScope::ConstPtr typeForId(const QQmlJSScope::ConstPtr &scope, const QString &name, QQmlJSScopesByIdOptions options) const
++ *
++ * \internal
++ *
++ * Same as scopedType(), but assumes that the \a name is an ID and only searches
++ * the context.
++ *
++ * TODO: This is just as wrong as scopedType() in that it disregards both scope
++ * properties overriding context properties and run time context
++ * properties.
++ */
++
++ bool QQmlJSTypeResolver::checkEnums(
++ QQmlJSRegisterContent scope, const QString &name,
++ QQmlJSRegisterContent *result) const
++ {
++ // You can't have lower case enum names in QML, even if we know the enums here.
++ if (name.isEmpty() || !name.at(0).isUpper())
++ return false;
++
++ const auto enums = scope.containedType()->ownEnumerations();
++ for (const auto &enumeration : enums) {
++ if (enumeration.name() == name) {
++ *result = m_pool->createEnumeration(
++ enumeration, QString(),
++ QQmlJSRegisterContent::Enum,
++ scope);
++ return true;
++ }
++
++ if (!(scope.containedType()->enforcesScopedEnums() && enumeration.isScoped())
++ && enumeration.hasKey(name)) {
++ *result = m_pool->createEnumeration(
++ enumeration, name,
++ QQmlJSRegisterContent::Enum,
++ scope);
++ return true;
++ }
++ }
++
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::canPopulate(
++ const QQmlJSScope::ConstPtr &type, const QQmlJSScope::ConstPtr &passedArgumentType,
++ bool *isExtension) const
++ {
++ // TODO: We could allow QVariantMap and QVariantHash to be populated, but that needs extra
++ // code in the code generator.
++
++ if (type.isNull()
++ || canHold(passedArgumentType, type)
++ || isPrimitive(passedArgumentType)
++ || type->accessSemantics() != QQmlJSScope::AccessSemantics::Value
++ || !type->isStructured()) {
++ return false;
++ }
++
++ if (isExtension)
++ *isExtension = !type->extensionType().scope.isNull();
++
++ return true;
++ }
++
++ QQmlJSMetaMethod QQmlJSTypeResolver::selectConstructor(
++ const QQmlJSScope::ConstPtr &type, const QQmlJSScope::ConstPtr &passedArgumentType,
++ bool *isExtension) const
++ {
++ // If the "from" type can hold the target type, we should not try to coerce
++ // it to any constructor argument.
++ if (type.isNull()
++ || canHold(passedArgumentType, type)
++ || type->accessSemantics() != QQmlJSScope::AccessSemantics::Value
++ || !type->isCreatable()) {
++ return QQmlJSMetaMethod();
++ }
++
++ auto doSelectConstructor = [&](const QQmlJSScope::ConstPtr &ctorProvider) {
++ QQmlJSMetaMethod candidate;
++
++ const auto ownMethods = ctorProvider->ownMethods();
++ for (const QQmlJSMetaMethod &method : ownMethods) {
++ if (!method.isConstructor())
++ continue;
++
++ const auto index = method.constructorIndex();
++ Q_ASSERT(index != QQmlJSMetaMethod::RelativeFunctionIndex::Invalid);
++
++ const auto methodArguments = method.parameters();
++ if (methodArguments.size() != 1)
++ continue;
++
++ const QQmlJSScope::ConstPtr methodArgumentType = methodArguments[0].type();
++
++ // Do not select the copy constructor (also not if disguised via the extension).
++ if (methodArgumentType == type)
++ continue;
++
++ if (passedArgumentType == methodArgumentType)
++ return method;
++
++ // Do not select further ctors here. We don't want to do multi-step construction as that
++ // is confusing and easily leads to infinite recursion.
++ if (!candidate.isValid()
++ && canPrimitivelyConvertFromTo(passedArgumentType, methodArgumentType)) {
++ candidate = method;
++ }
++ }
++
++ return candidate;
++ };
++
++ if (QQmlJSScope::ConstPtr extension = type->extensionType().scope) {
++ const QQmlJSMetaMethod ctor = doSelectConstructor(extension);
++ if (ctor.isValid()) {
++ if (isExtension)
++ *isExtension = true;
++ return ctor;
++ }
++ }
++
++ if (isExtension)
++ *isExtension = false;
++
++ return doSelectConstructor(type);
++ }
++
++ bool QQmlJSTypeResolver::areEquivalentLists(
++ const QQmlJSScope::ConstPtr &a, const QQmlJSScope::ConstPtr &b) const
++ {
++ const QQmlJSScope::ConstPtr equivalentLists[2][2] = {
++ { m_stringListType, m_stringType->listType() },
++ { m_variantListType, m_varType->listType() }
++ };
++
++ for (const auto eq : equivalentLists) {
++ if ((a == eq[0] && b == eq[1]) || (a == eq[1] && b == eq[0]))
++ return true;
++ }
++
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::isTriviallyCopyable(const QQmlJSScope::ConstPtr &type) const
++ {
++ // pointers are trivially copyable
++ if (type->isReferenceType())
++ return true;
++
++ // Enum values are trivially copyable
++ if (type->scopeType() == QQmlSA::ScopeType::EnumScope)
++ return true;
++
++ for (const QQmlJSScope::ConstPtr &trivial : {
++ m_nullType, m_voidType,
++ m_boolType, m_metaObjectType,
++ m_realType, m_floatType,
++ m_int8Type, m_uint8Type,
++ m_int16Type, m_uint16Type,
++ m_int32Type, m_uint32Type,
++ m_int64Type, m_uint64Type }) {
++ if (type == trivial)
++ return true;
++ }
++
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::inherits(const QQmlJSScope::ConstPtr &derived, const QQmlJSScope::ConstPtr &base) const
++ {
++ const bool matchByName = !base->isComposite();
++ for (QQmlJSScope::ConstPtr derivedBase = derived; derivedBase;
++ derivedBase = derivedBase->baseType()) {
++ if (derivedBase == base)
++ return true;
++ if (matchByName
++ && !derivedBase->isComposite()
++ && derivedBase->internalName() == base->internalName()) {
++ return true;
++ }
++ }
++ return false;
++ }
++
++ bool QQmlJSTypeResolver::canPrimitivelyConvertFromTo(
++ const QQmlJSScope::ConstPtr &from, const QQmlJSScope::ConstPtr &to) const
++ {
++ if (from == to)
++ return true;
++ if (from == m_varType || to == m_varType)
++ return true;
++ if (from == m_jsValueType || to == m_jsValueType)
++ return true;
++ if (to == m_qQmlScriptStringType)
++ return true;
++ if (isNumeric(from) && isNumeric(to))
++ return true;
++ // We can convert everything to bool.
++ if (to == m_boolType)
++ return true;
++
++ if (from->accessSemantics() == QQmlJSScope::AccessSemantics::Reference
++ && to == m_stringType) {
++ return true;
++ }
++
++ // Yes, our String has number constructors.
++ if (isNumeric(from) && to == m_stringType)
++ return true;
++
++ // We can convert strings to numbers, but not to enums
++ if (from == m_stringType && isNumeric(to))
++ return to->scopeType() != QQmlJSScope::ScopeType::EnumScope;
++
++ // We can always convert between strings and urls.
++ if ((from == m_stringType && to == m_urlType)
++ || (from == m_urlType && to == m_stringType)) {
++ return true;
++ }
++
++ // We can always convert between strings and byte arrays.
++ if ((from == m_stringType && to == m_byteArrayType)
++ || (from == m_byteArrayType && to == m_stringType)) {
++ return true;
++ }
++
++ if (to == m_voidType)
++ return true;
++
++ if (to.isNull())
++ return from == m_voidType;
++
++ const auto types = { m_dateTimeType, m_dateType, m_timeType, m_stringType };
++ for (const auto &originType : types) {
++ if (from != originType)
++ continue;
++
++ for (const auto &targetType : types) {
++ if (to == targetType)
++ return true;
++ }
++
++ if (to == m_realType)
++ return true;
++
++ break;
++ }
++
++ if (from == m_nullType && to->accessSemantics() == QQmlJSScope::AccessSemantics::Reference)
++ return true;
++
++ if (from == m_jsPrimitiveType) {
++ // You can cast any primitive to a nullptr
++ return isPrimitive(to) || to->accessSemantics() == QQmlJSScope::AccessSemantics::Reference;
++ }
++
++ if (to == m_jsPrimitiveType)
++ return isPrimitive(from);
++
++ const bool matchByName = !to->isComposite();
++ Q_ASSERT(!matchByName || !to->internalName().isEmpty());
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(
++ from, [&](const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ExtensionKind kind) {
++ switch (kind) {
++ case QQmlJSScope::NotExtension:
++ case QQmlJSScope::ExtensionJavaScript:
++ // Converting to a base type is trivially supported.
++ // Converting to the JavaScript extension of a type just produces the type itself.
++ // Giving the JavaScript extension as type to be converted to means we expect any
++ // result that fulfills the given JavaScript interface.
++ return scope == to
++ || (matchByName && scope->internalName() == to->internalName());
++ case QQmlJSScope::ExtensionType:
++ case QQmlJSScope::ExtensionNamespace:
++ break;
++ }
++ return false;
++ })) {
++ return true;
++ }
++
++ if (from == m_variantListType)
++ return to->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence;
++
++ // We can convert anything that fits natively into QJSPrimitiveValue
++ if (canPrimitivelyConvertFromTo(from, m_jsPrimitiveType)
++ && canPrimitivelyConvertFromTo(m_jsPrimitiveType, to)) {
++ return true;
++ }
++
++ if (areEquivalentLists(from, to))
++ return true;
++
++ if (from->isListProperty()
++ && to->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence
++ && canConvertFromTo(from->elementType(), to->elementType())) {
++ return true;
++ }
++
++ // it is possible to assing a singlar object to a list property if it could be stored in the list
++ if (to->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence
++ && from->accessSemantics() == QQmlJSScope::AccessSemantics::Reference
++ && from->inherits(to->elementType())) {
++ return true;
++ }
++
++ if (to == m_stringType && from->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence)
++ return canConvertFromTo(from->elementType(), m_stringType);
++
++ return false;
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::lengthProperty(
++ bool isWritable, QQmlJSRegisterContent scope) const
++ {
++ QQmlJSMetaProperty prop;
++ prop.setPropertyName(u"length"_s);
++ prop.setTypeName(u"qsizetype"_s);
++ prop.setType(sizeType());
++ prop.setIsWritable(isWritable);
++ return m_pool->createProperty(
++ prop, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::Property, scope);
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::memberType(
++ QQmlJSRegisterContent type, const QString &name, int baseLookupIndex,
++ int resultLookupIndex) const
++ {
++ QQmlJSRegisterContent result;
++ const QQmlJSScope::ConstPtr contained = type.containedType();
++
++ // If we got a plain type reference we have to check the enums of the _scope_.
++ if (contained == metaObjectType())
++ return memberEnumType(type.scope(), name);
++
++ if (contained == variantMapType() || contained->inherits(qmlPropertyMapType())) {
++ QQmlJSMetaProperty prop;
++ prop.setPropertyName(name);
++ prop.setTypeName(u"QVariant"_s);
++ prop.setType(varType());
++ prop.setIsWritable(true);
++ return m_pool->createProperty(
++ prop, baseLookupIndex, resultLookupIndex,
++ QQmlJSRegisterContent::Property, type);
++ }
++
++ if (contained == jsValueType()) {
++ QQmlJSMetaProperty prop;
++ prop.setPropertyName(name);
++ prop.setTypeName(u"QJSValue"_s);
++ prop.setType(jsValueType());
++ prop.setIsWritable(true);
++ return m_pool->createProperty(
++ prop, baseLookupIndex, resultLookupIndex,
++ QQmlJSRegisterContent::Property, type);
++ }
++
++ if ((contained == stringType()
++ || contained->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence)
++ && name == u"length"_s) {
++ return lengthProperty(contained != stringType(), type);
++ }
++
++ const auto check = [&](const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ExtensionKind mode) {
++ const QQmlJSRegisterContent resultScope = mode == QQmlJSScope::NotExtension
++ ? baseType(scope, type)
++ : extensionType(scope, type);
++
++ if (mode != QQmlJSScope::ExtensionNamespace) {
++ if (scope->hasOwnProperty(name)) {
++ const auto prop = scope->ownProperty(name);
++ result = m_pool->createProperty(
++ prop, baseLookupIndex, resultLookupIndex,
++ QQmlJSRegisterContent::Property, resultScope);
++ return true;
++ }
++
++ if (scope->hasOwnMethod(name)) {
++ const auto methods = scope->ownMethods(name);
++ result = m_pool->createMethod(
++ methods, jsValueType(), QQmlJSRegisterContent::Method, resultScope);
++ return true;
++ }
++ }
++ // don't look up enums on ids...
++ if (type.variant() == QQmlJSRegisterContent::ObjectById)
++ return false;
++ return checkEnums(resultScope, name, &result);
++ };
++
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(type.containedType(), check))
++ return result;
++
++ for (auto scope = contained;
++ scope && (QQmlSA::isFunctionScope(scope->scopeType())
++ || scope->scopeType() == QQmlSA::ScopeType::JSLexicalScope);
++ scope = scope->parentScope()) {
++ if (auto ownIdentifier = scope->ownJSIdentifier(name)) {
++ QQmlJSMetaProperty prop;
++ prop.setPropertyName(name);
++ prop.setTypeName(u"QJSValue"_s);
++ prop.setType(jsValueType());
++ prop.setIsWritable(!(ownIdentifier.value().isConst));
++
++ return m_pool->createProperty(
++ prop, baseLookupIndex, resultLookupIndex,
++ QQmlJSRegisterContent::Property,
++ parentScope(scope, type));
++ }
++ }
++
++ // check enums before checking attached types of attached types (chained attached types)
++ if (type.isType()) {
++ if (auto result = memberEnumType(type.scope(), name); result.isValid())
++ return result;
++ }
++
++ if (QQmlJSScope::ConstPtr attachedBase = typeForName(name)) {
++ if (QQmlJSScope::ConstPtr attached = attachedBase->attachedType()) {
++ if (!genericType(attached)) {
++ m_logger->log(u"Cannot resolve generic base of attached %1"_s.arg(
++ attached->internalName()),
++ qmlCompiler, attached->sourceLocation());
++ return {};
++ } else if (contained->accessSemantics() != QQmlJSScope::AccessSemantics::Reference) {
++ m_logger->log(u"Cannot retrieve attached object for non-reference type %1"_s.arg(
++ contained->internalName()),
++ qmlCompiler, contained->sourceLocation());
++ return {};
++ } else {
++ const QQmlJSRegisterContent namedType = m_pool->createType(
++ attachedBase, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::TypeByName, type);
++
++ return m_pool->createType(
++ attached, resultLookupIndex, QQmlJSRegisterContent::Attachment,
++ namedType);
++ }
++ }
++ }
++
++ return {};
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::memberEnumType(
++ QQmlJSRegisterContent type, const QString &name) const
++ {
++ QQmlJSRegisterContent result;
++
++ if (QQmlJSUtils::searchBaseAndExtensionTypes(
++ type.containedType(),
++ [&](const QQmlJSScope::ConstPtr &scope, QQmlJSScope::ExtensionKind mode) {
++ return checkEnums(mode == QQmlJSScope::NotExtension
++ ? baseType(scope, type)
++ : extensionType(scope, type),
++ name, &result);
++ })) {
++ return result;
++ }
++
++ return {};
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::memberType(
++ QQmlJSRegisterContent type, const QString &name, int lookupIndex) const
++ {
++ if (type.isType())
++ return memberType(type, name, type.resultLookupIndex(), lookupIndex);
++ if (type.isProperty() || type.isMethodCall())
++ return memberType(type, name, type.resultLookupIndex(), lookupIndex);
++ if (type.isEnumeration()) {
++ const auto enumeration = type.enumeration();
++ if (!type.enumMember().isEmpty() || !enumeration.hasKey(name))
++ return {};
++ return m_pool->createEnumeration(
++ enumeration, name, QQmlJSRegisterContent::Enum, type.scope());
++ }
++ if (type.isMethod()) {
++ QQmlJSMetaProperty prop;
++ prop.setTypeName(u"QJSValue"_s);
++ prop.setPropertyName(name);
++ prop.setType(jsValueType());
++ prop.setIsWritable(true);
++ return m_pool->createProperty(
++ prop, QQmlJSRegisterContent::InvalidLookupIndex, lookupIndex,
++ QQmlJSRegisterContent::Property, type);
++ }
++ if (type.isImportNamespace()) {
++ Q_ASSERT(type.scopeType()->isReferenceType());
++ return registerContentForName(name, type);
++ }
++ if (type.isConversion()) {
++ if (const auto result = memberType(
++ type, name, type.resultLookupIndex(), lookupIndex);
++ result.isValid()) {
++ return result;
++ }
++
++ if (const auto result = memberEnumType(type.scope(), name); result.isValid())
++ return result;
++
++ // If the conversion consists of only undefined and one actual type,
++ // we can produce the members of that one type.
++ // If the value is then actually undefined, the result is an exception.
++
++ const auto nonVoid = extractNonVoidFromOptionalType(type);
++
++ // If the conversion cannot hold the original type, it loses information.
++ return (!nonVoid.isNull() && canHold(type.conversionResultType(), nonVoid.containedType()))
++ ? memberType(nonVoid, name, type.resultLookupIndex(), lookupIndex)
++ : QQmlJSRegisterContent();
++ }
++
++ Q_UNREACHABLE_RETURN({});
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::elementType(QQmlJSRegisterContent list) const
++ {
++ QQmlJSScope::ConstPtr value;
++
++ auto valueType = [&](const QQmlJSScope::ConstPtr &scope) -> QQmlJSScope::ConstPtr {
++ if (scope->accessSemantics() == QQmlJSScope::AccessSemantics::Sequence)
++ return scope->elementType();
++
++ if (scope == m_forInIteratorPtr)
++ return m_sizeType;
++
++ if (scope == m_forOfIteratorPtr)
++ return list.scopeType()->elementType();
++
++ if (scope == m_jsValueType || scope == m_varType)
++ return m_jsValueType;
++
++ if (scope == m_stringType)
++ return m_stringType;
++
++ return QQmlJSScope::ConstPtr();
++ };
++
++ value = valueType(list.containedType());
++
++ if (value.isNull())
++ return {};
++
++ QQmlJSMetaProperty property;
++ property.setPropertyName(u"[]"_s);
++ property.setTypeName(value->internalName());
++ property.setType(value);
++
++ return m_pool->createProperty(
++ property, QQmlJSRegisterContent::InvalidLookupIndex,
++ QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::ListValue,
++ list);
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::returnType(
++ const QQmlJSMetaMethod &method, const QQmlJSScope::ConstPtr &returnType,
++ QQmlJSRegisterContent scope) const
++ {
++ return m_pool->createMethodCall(method, returnType, scope);
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::extensionType(
++ const QQmlJSScope::ConstPtr &extension, QQmlJSRegisterContent base) const
++ {
++ return m_pool->createType(
++ extension, base.resultLookupIndex(), QQmlJSRegisterContent::Extension, base);
++ }
++
++ /*!
++ * \internal
++ * Encodes \a base as a base type of \a derived and returns a QQmlJSRegisterContent.
++ * "Base type" here is understood the same way as std::is_base_of would understand it.
++ * That means, if you pass the contained type of \a derived as \a base, then \a derived
++ * itself is returned.
++ */
++ QQmlJSRegisterContent QQmlJSTypeResolver::baseType(
++ const QQmlJSScope::ConstPtr &base, QQmlJSRegisterContent derived) const
++ {
++ return m_pool->createType(
++ base, derived.resultLookupIndex(), QQmlJSRegisterContent::BaseType, derived);
++ }
++
++ /*!
++ * \internal
++ * Encodes \a parent as a parent scope of \a child and returns a QQmlJSRegisterContent.
++ * "Parent scope" here means any scope above, but also _including_ \a child.
++ * That means, if you pass the contained type of \a child as \a parent, then \a child
++ * itself is returned.
++ */
++ QQmlJSRegisterContent QQmlJSTypeResolver::parentScope(
++ const QQmlJSScope::ConstPtr &parent, QQmlJSRegisterContent child) const
++ {
++ return m_pool->createType(
++ parent, child.resultLookupIndex(), QQmlJSRegisterContent::ParentScope, child);
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::iteratorPointer(
++ QQmlJSRegisterContent listType, QQmlJS::AST::ForEachType type,
++ int lookupIndex) const
++ {
++ const QQmlJSScope::ConstPtr value = (type == QQmlJS::AST::ForEachType::In)
++ ? m_int32Type
++ : elementType(listType).containedType();
++
++ QQmlJSScope::ConstPtr iteratorPointer = type == QQmlJS::AST::ForEachType::In
++ ? m_forInIteratorPtr
++ : m_forOfIteratorPtr;
++
++ QQmlJSMetaProperty prop;
++ prop.setPropertyName(u"<>"_s);
++ prop.setTypeName(iteratorPointer->internalName());
++ prop.setType(iteratorPointer);
++ return m_pool->createProperty(
++ prop, lookupIndex,
++ QQmlJSRegisterContent::InvalidLookupIndex, QQmlJSRegisterContent::ListIterator,
++ listType);
++ }
++
++ QQmlJSScope::ConstPtr QQmlJSTypeResolver::storedType(const QQmlJSScope::ConstPtr &type) const
++ {
++ if (type.isNull())
++ return {};
++ if (type == voidType())
++ return type;
++ if (type->isScript())
++ return jsValueType();
++ if (type->isComposite()) {
++ if (const QQmlJSScope::ConstPtr nonComposite = QQmlJSScope::nonCompositeBaseType(type))
++ return nonComposite;
++
++ // If we can't find the non-composite base, we really don't know what it is.
++ return genericType(type);
++ }
++ if (type->filePath().isEmpty())
++ return genericType(type);
++ return type;
++ }
++
++ static QQmlJSRegisterContent doConvert(
++ QQmlJSRegisterContent from, const QQmlJSScope::ConstPtr &to,
++ QQmlJSRegisterContent scope, QQmlJSRegisterContentPool *pool)
++ {
++ if (from.isConversion()) {
++ return pool->createConversion(
++ from.conversionOrigins(), to,
++ scope.isValid() ? scope : from.conversionResultScope(),
++ from.variant(), from.scope());
++ }
++
++ return pool->createConversion(
++ QList<QQmlJSRegisterContent>{from},
++ to, scope, from.variant(),
++ from.scope());
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::convert(
++ QQmlJSRegisterContent from, QQmlJSRegisterContent to) const
++ {
++ return doConvert(from, to.containedType(), to.scope(), m_pool.get());
++ }
++
++ QQmlJSRegisterContent QQmlJSTypeResolver::convert(
++ QQmlJSRegisterContent from, const QQmlJSScope::ConstPtr &to) const
++ {
++ return doConvert(from, to, QQmlJSRegisterContent(), m_pool.get());
++ }
++
++ QT_END_NAMESPACE