qqmlcomponent.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qqmlcomponent.h"
#include "qqmlcomponent_p.h"
#include "qqmlcomponentattached_p.h"
 
#include "qqmlengine_p.h"
#include "qqmlvme_p.h"
#include "qqml.h"
#include "qqmlengine.h"
#include "qqmlincubator.h"
#include "qqmlincubator_p.h"
#include <private/qqmljavascriptexpression_p.h>
#include <private/qqmlsourcecoordinate_p.h>
 
#include <private/qv4functionobject_p.h>
#include <private/qv4script_p.h>
#include <private/qv4scopedvalue_p.h>
#include <private/qv4objectiterator_p.h>
#include <private/qv4qobjectwrapper_p.h>
#include <private/qv4jscall_p.h>
 
#include <QDir>
#include <QStack>
#include <QStringList>
#include <QThreadStorage>
#include <QtCore/qdebug.h>
#include <QtCore/qloggingcategory.h>
#include <qqmlinfo.h>
 
 
using namespace Qt::Literals::StringLiterals;
 
namespace {
    Q_CONSTINIT thread_local int creationDepth = 0;
}
 
Q_LOGGING_CATEGORY(lcQmlComponentGeneral, "qt.qml.qmlcomponent")
 
QT_BEGIN_NAMESPACE
 
class QQmlComponentExtension : public QV4::ExecutionEngine::Deletable
{
public:
    QQmlComponentExtension(QV4::ExecutionEngine *v4);
    virtual ~QQmlComponentExtension();
 
    QV4::PersistentValue incubationProto;
};
V4_DEFINE_EXTENSION(QQmlComponentExtension, componentExtension);
 
void QQmlComponentPrivate::typeDataReady(QQmlTypeData *)
{
    Q_Q(QQmlComponent);
 
    Q_ASSERT(typeData);
 
    fromTypeData(typeData);
    typeData.reset();
    progress = 1.0;
 
    emit q->statusChanged(q->status());
    emit q->progressChanged(progress);
}
 
void QQmlComponentPrivate::typeDataProgress(QQmlTypeData *, qreal p)
{
    Q_Q(QQmlComponent);
 
    progress = p;
 
    emit q->progressChanged(p);
}
 
void QQmlComponentPrivate::fromTypeData(const QQmlRefPointer<QQmlTypeData> &data)
{
    url = data->finalUrl();
    if (auto cu = data->compilationUnit())
        compilationUnit = engine->handle()->executableCompilationUnit(std::move(cu));
 
    if (!compilationUnit) {
        Q_ASSERT(data->isError());
        state.errors.clear();
        state.appendErrors(data->errors());
    }
}
 
bool QQmlComponentPrivate::hadTopLevelRequiredProperties() const
{
    return state.creator()->componentHadTopLevelRequiredProperties();
}
 
void QQmlComponentPrivate::clear()
{
    if (typeData) {
        typeData->unregisterCallback(this);
        typeData.reset();
    }
 
    compilationUnit.reset();
    loadedType = {};
    inlineComponentName.reset();
}
 
QObject *QQmlComponentPrivate::doBeginCreate(QQmlComponent *q, QQmlContext *context)
{
    if (!engine) {
        // ###Qt6: In Qt 6, it should be impossible for users to create a QQmlComponent without an engine, and we can remove this check
        qWarning("QQmlComponent: Must provide an engine before calling create");
        return nullptr;
    }
    if (!context)
        context = engine->rootContext();
    return q->beginCreate(context);
}
 
static void removePendingQPropertyBinding(
    QV4::Value *object, const QString &propertyName, QQmlObjectCreator *creator)
{
    if (!creator)
        return;
 
    QV4::QObjectWrapper *wrapper = object->as<QV4::QObjectWrapper>();
    if (!wrapper)
        return;
 
    QObject *o = wrapper->object();
    if (!o)
        return;
 
    if (QQmlData *ddata = QQmlData::get(o)) {
        const QQmlPropertyData *propData = ddata->propertyCache->property(
            propertyName, o, ddata->outerContext);
        if (propData && propData->isBindable())
            creator->removePendingBinding(o, propData->coreIndex());
        return;
    }
 
    const QMetaObject *meta = o->metaObject();
    Q_ASSERT(meta);
    const int index = meta->indexOfProperty(propertyName.toUtf8());
    if (index != -1 && meta->property(index).isBindable())
        creator->removePendingBinding(o, index);
}
 
bool QQmlComponentPrivate::setInitialProperty(
        QObject *base, const QString &name, const QVariant &value)
{
    const QStringList properties = name.split(u'.');
 
    if (properties.size() > 1) {
        QV4::Scope scope(engine->handle());
        QV4::ScopedObject object(scope, QV4::QObjectWrapper::wrap(scope.engine, base));
        QV4::ScopedString segment(scope);
 
        for (int i = 0; i < properties.size() - 1; ++i) {
            segment = scope.engine->newString(properties.at(i));
            object = object->get(segment);
            if (scope.engine->hasException)
                break;
        }
        const QString lastProperty = properties.last();
        segment = scope.engine->newString(lastProperty);
        object->put(segment, scope.engine->metaTypeToJS(value.metaType(), value.constData()));
        if (scope.engine->hasException) {
            qmlWarning(base, scope.engine->catchExceptionAsQmlError());
            scope.engine->hasException = false;
            return false;
        }
 
        removePendingQPropertyBinding(object, lastProperty, state.creator());
        return true;
    }
 
    QQmlProperty prop;
    if (state.hasUnsetRequiredProperties())
        prop = QQmlComponentPrivate::removePropertyFromRequired(
                    base, name, state.requiredProperties(), engine);
    else
        prop = QQmlProperty(base, name, engine);
    QQmlPropertyPrivate *privProp = QQmlPropertyPrivate::get(prop);
    const bool isValid = prop.isValid();
    if (isValid && privProp->writeValueProperty(value, {})) {
        if (prop.isBindable()) {
            if (QQmlObjectCreator *creator = state.creator())
                creator->removePendingBinding(prop.object(), prop.index());
        }
    } else {
        QQmlError error{};
        error.setUrl(url);
        if (isValid) {
            error.setDescription(QStringLiteral("Could not set initial property %1").arg(name));
        } else {
            error.setDescription(QStringLiteral("Setting initial properties failed: "
                                                "%2 does not have a property called %1")
                                         .arg(name, QQmlMetaType::prettyTypeName(base)));
        }
        qmlWarning(base, error);
        return false;
    }
 
    return true;
 
}
 
QQmlComponent::QQmlComponent(QObject *parent)
    : QObject(*(new QQmlComponentPrivate), parent)
{
}
 
QQmlComponent::~QQmlComponent()
{
    Q_D(QQmlComponent);
 
    if (d->state.isCompletePending()) {
        qWarning("QQmlComponent: Component destroyed while completion pending");
 
        if (isError()) {
            qWarning() << "This may have been caused by one of the following errors:";
            for (const QQmlComponentPrivate::AnnotatedQmlError &e : std::as_const(d->state.errors))
                qWarning().nospace().noquote() << QLatin1String("    ") << e.error;
        }
 
        // we might not have the creator anymore if the engine is gone
        if (d->state.hasCreator())
            d->completeCreate();
    }
 
    if (d->typeData) {
        d->typeData->unregisterCallback(d);
        d->typeData.reset();
    }
}
 
QQmlComponent::Status QQmlComponent::status() const
{
    Q_D(const QQmlComponent);
 
    if (d->typeData)
        return Loading;
    else if (!d->state.errors.isEmpty())
        return Error;
    else if (d->engine && (d->compilationUnit || d->loadedType.isValid()))
        return Ready;
    else
        return Null;
}
 
bool QQmlComponent::isNull() const
{
    return status() == Null;
}
 
bool QQmlComponent::isReady() const
{
    return status() == Ready;
}
 
bool QQmlComponent::isError() const
{
    return status() == Error;
}
 
bool QQmlComponent::isLoading() const
{
    return status() == Loading;
}
 
bool QQmlComponent::isBound() const
{
    Q_D(const QQmlComponent);
    return d->isBound();
}
 
qreal QQmlComponent::progress() const
{
    Q_D(const QQmlComponent);
    return d->progress;
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, QObject *parent)
    : QObject(*(new QQmlComponentPrivate), parent)
{
    Q_D(QQmlComponent);
    d->engine = engine;
    QObject::connect(engine, &QObject::destroyed, this, [d]() {
        d->state.clear();
        d->engine = nullptr;
    });
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QUrl &url, QObject *parent)
    : QQmlComponent(engine, url, QQmlComponent::PreferSynchronous, parent)
{
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QUrl &url, CompilationMode mode,
                             QObject *parent)
    : QQmlComponent(engine, parent)
{
    Q_D(QQmlComponent);
    d->loadUrl(url, mode);
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, QAnyStringView uri, QAnyStringView typeName, QObject *parent)
    : QQmlComponent(engine, uri, typeName, QQmlComponent::PreferSynchronous, parent)
{
 
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, QAnyStringView uri, QAnyStringView typeName, CompilationMode mode, QObject *parent)
    : QQmlComponent(engine, parent)
{
    loadFromModule(uri, typeName, mode);
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QString &fileName,
                             QObject *parent)
    : QQmlComponent(engine, fileName, QQmlComponent::PreferSynchronous, parent)
{
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, const QString &fileName,
                             CompilationMode mode, QObject *parent)
    : QQmlComponent(engine, parent)
{
    Q_D(QQmlComponent);
    if (fileName.startsWith(u':'))
        d->loadUrl(QUrl(QLatin1String("qrc") + fileName), mode);
    else if (QDir::isAbsolutePath(fileName))
        d->loadUrl(QUrl::fromLocalFile(fileName), mode);
    else
        d->loadUrl(QUrl(fileName), mode);
}
 
QQmlComponent::QQmlComponent(QQmlEngine *engine, QV4::ExecutableCompilationUnit *compilationUnit,
                             int start, QObject *parent)
    : QQmlComponent(engine, parent)
{
    Q_D(QQmlComponent);
    d->compilationUnit.reset(compilationUnit);
    d->start = start;
    d->url = compilationUnit->finalUrl();
    d->progress = 1.0;
}
 
void QQmlComponent::setData(const QByteArray &data, const QUrl &url)
{
    Q_D(QQmlComponent);
 
    if (!d->engine) {
        // ###Qt6: In Qt 6, it should be impossible for users to create a QQmlComponent without an engine, and we can remove this check
        qWarning("QQmlComponent: Must provide an engine before calling setData");
        return;
    }
 
    d->clear();
 
    d->url = url;
 
    QQmlRefPointer<QQmlTypeData> typeData = QQmlEnginePrivate::get(d->engine)->typeLoader.getType(data, url);
 
    if (typeData->isCompleteOrError()) {
        d->fromTypeData(typeData);
    } else {
        d->typeData = typeData;
        d->typeData->registerCallback(d);
    }
 
    d->progress = 1.0;
    emit statusChanged(status());
    emit progressChanged(d->progress);
}
 
QQmlContext *QQmlComponent::creationContext() const
{
    Q_D(const QQmlComponent);
    if (!d->creationContext.isNull())
        return d->creationContext->asQQmlContext();
 
    return qmlContext(this);
}
 
QQmlEngine *QQmlComponent::engine() const
{
    Q_D(const QQmlComponent);
    return d->engine;
}
 
void QQmlComponent::loadUrl(const QUrl &url)
{
    Q_D(QQmlComponent);
    d->loadUrl(url);
}
 
void QQmlComponent::loadUrl(const QUrl &url, QQmlComponent::CompilationMode mode)
{
    Q_D(QQmlComponent);
    d->loadUrl(url, mode);
}
 
void QQmlComponentPrivate::loadUrl(const QUrl &newUrl, QQmlComponent::CompilationMode mode)
{
    Q_Q(QQmlComponent);
    clear();
 
    if (newUrl.isRelative()) {
        // The new URL is a relative URL like QUrl("main.qml").
        url = engine->baseUrl().resolved(QUrl(newUrl.toString()));
    } else if (engine->baseUrl().isLocalFile() && newUrl.isLocalFile() && !QDir::isAbsolutePath(newUrl.toLocalFile())) {
        // The new URL is a file on disk but it's a relative path; e.g.:
        // QUrl::fromLocalFile("main.qml") or QUrl("file:main.qml")
        // We need to remove the scheme so that it becomes a relative URL with a relative path:
        QUrl fixedUrl(newUrl);
        fixedUrl.setScheme(QString());
        // Then, turn it into an absolute URL with an absolute path by resolving it against the engine's baseUrl().
        // This is a compatibility hack for QTBUG-58837.
        url = engine->baseUrl().resolved(fixedUrl);
    } else {
        url = newUrl;
    }
 
    if (newUrl.isEmpty()) {
        QQmlError error;
        error.setDescription(QQmlComponent::tr("Invalid empty URL"));
        state.errors.emplaceBack(error);
        return;
    }
 
    if (progress != 0.0) {
        progress = 0.0;
        emit q->progressChanged(progress);
    }
 
    QQmlTypeLoader::Mode loaderMode = (mode == QQmlComponent::Asynchronous)
            ? QQmlTypeLoader::Asynchronous
            : QQmlTypeLoader::PreferSynchronous;
    QQmlRefPointer<QQmlTypeData> data = QQmlEnginePrivate::get(engine)->typeLoader.getType(url, loaderMode);
 
    if (data->isCompleteOrError()) {
        fromTypeData(data);
        progress = 1.0;
    } else {
        typeData = data;
        typeData->registerCallback(this);
        progress = data->progress();
    }
 
    emit q->statusChanged(q->status());
    if (progress != 0.0)
        emit q->progressChanged(progress);
}
 
QList<QQmlError> QQmlComponent::errors() const
{
    Q_D(const QQmlComponent);
    QList<QQmlError> errors;
    errors.reserve(d->state.errors.size());
    for (const QQmlComponentPrivate::AnnotatedQmlError &annotated : d->state.errors)
        errors.emplaceBack(annotated.error);
    return errors;
}
 
QString QQmlComponent::errorString() const
{
    Q_D(const QQmlComponent);
    QString ret;
    if(!isError())
        return ret;
    for (const QQmlComponentPrivate::AnnotatedQmlError &annotated : d->state.errors) {
        const QQmlError &e = annotated.error;
        ret += e.url().toString() + QLatin1Char(':') +
               QString::number(e.line()) + QLatin1Char(' ') +
               e.description() + QLatin1Char('\n');
    }
    return ret;
}
 
QUrl QQmlComponent::url() const
{
    Q_D(const QQmlComponent);
    return d->url;
}
 
QQmlComponent::QQmlComponent(QQmlComponentPrivate &dd, QObject *parent)
    : QObject(dd, parent)
{
}
 
QObject *QQmlComponent::create(QQmlContext *context)
{
    Q_D(QQmlComponent);
    return d->createWithProperties(nullptr, QVariantMap {}, context);
}
 
QObject *QQmlComponent::createWithInitialProperties(const QVariantMap& initialProperties, QQmlContext *context)
{
    Q_D(QQmlComponent);
    return d->createWithProperties(nullptr, initialProperties, context);
}
 
static void QQmlComponent_setQmlParent(QObject *me, QObject *parent); // forward declaration
 
QObject *QQmlComponentPrivate::createWithProperties(QObject *parent, const QVariantMap &properties,
                                                    QQmlContext *context, CreateBehavior behavior)
{
    Q_Q(QQmlComponent);
 
    QObject *rv = doBeginCreate(q, context);
    if (!rv) {
        if (state.isCompletePending()) {
            // overridden completCreate might assume that
            // the object has actually been created
            ++creationDepth;
            QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
            complete(ep, &state);
            --creationDepth;
        }
        return nullptr;
    }
 
    QQmlComponent_setQmlParent(rv, parent); // internally checks if parent is nullptr
 
    q->setInitialProperties(rv, properties);
    q->completeCreate();
 
    if (state.hasUnsetRequiredProperties()) {
        if (behavior == CreateWarnAboutRequiredProperties) {
            for (const auto &unsetRequiredProperty : std::as_const(*state.requiredProperties())) {
                const QQmlError error = unsetRequiredPropertyToQQmlError(unsetRequiredProperty);
                qmlWarning(rv, error);
            }
        }
        delete rv;
        rv = nullptr;
    }
    return rv;
}
 
QObject *QQmlComponent::beginCreate(QQmlContext *context)
{
    Q_D(QQmlComponent);
    Q_ASSERT(context);
    return d->beginCreate(QQmlContextData::get(context));
}
 
QObject *QQmlComponentPrivate::beginCreate(QQmlRefPointer<QQmlContextData> context)
{
    Q_Q(QQmlComponent);
    auto cleanup = qScopeGuard([this] {
        if (!state.errors.isEmpty() && lcQmlComponentGeneral().isDebugEnabled()) {
            for (const auto &e : std::as_const(state.errors)) {
                qCDebug(lcQmlComponentGeneral) << "QQmlComponent: " << e.error.toString();
            }
        }
    });
    if (!context) {
        qWarning("QQmlComponent: Cannot create a component in a null context");
        return nullptr;
    }
 
    if (!context->isValid()) {
        qWarning("QQmlComponent: Cannot create a component in an invalid context");
        return nullptr;
    }
 
    if (context->engine() != engine) {
        qWarning("QQmlComponent: Must create component in context from the same QQmlEngine");
        return nullptr;
    }
 
    if (state.isCompletePending()) {
        qWarning("QQmlComponent: Cannot create new component instance before completing the previous");
        return nullptr;
    }
 
    // filter out temporary errors as they do not really affect component's
    // state (they are not part of the document compilation)
    state.errors.removeIf([](const auto &e) { return e.isTransient; });
    state.clearRequiredProperties();
 
    if (!q->isReady()) {
        qWarning("QQmlComponent: Component is not ready");
        return nullptr;
    }
 
    // Do not create infinite recursion in object creation
    static const int maxCreationDepth = 10;
    if (creationDepth >= maxCreationDepth) {
        qWarning("QQmlComponent: Component creation is recursing - aborting");
        return nullptr;
    }
 
    QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(engine);
 
    enginePriv->inProgressCreations++;
    state.errors.clear();
    state.setCompletePending(true);
 
    QObject *rv = nullptr;
 
    if (!loadedType.isValid()) {
        enginePriv->referenceScarceResources();
        state.initCreator(std::move(context), compilationUnit, creationContext);
 
        QQmlObjectCreator::CreationFlags flags;
        if (const QString *icName = inlineComponentName.get()) {
            flags = QQmlObjectCreator::InlineComponent;
            if (start == -1)
                start = compilationUnit->inlineComponentId(*icName);
            Q_ASSERT(start > 0);
        } else {
            flags = QQmlObjectCreator::NormalObject;
        }
 
        rv = state.creator()->create(start, nullptr, nullptr, flags);
        if (!rv)
            state.appendCreatorErrors();
        enginePriv->dereferenceScarceResources();
    } else {
        // TODO: extract into function
        rv = loadedType.createWithQQmlData();
        QQmlPropertyCache::ConstPtr propertyCache = QQmlData::ensurePropertyCache(rv);
        QQmlParserStatus *parserStatus = nullptr;
        const int parserStatusCast = loadedType.parserStatusCast();
        if (parserStatusCast != -1) {
            parserStatus = reinterpret_cast<QQmlParserStatus*>(reinterpret_cast<char *>(rv) + parserStatusCast);
            parserStatus->classBegin();
        }
        for (int i = 0, propertyCount = propertyCache->propertyCount(); i < propertyCount; ++i) {
            if (const QQmlPropertyData *propertyData = propertyCache->property(i); propertyData->isRequired()) {
                state.ensureRequiredPropertyStorage();
                RequiredPropertyInfo info;
                info.propertyName = propertyData->name(rv);
                state.addPendingRequiredProperty(rv, propertyData, info);
            }
        }
        if (parserStatus)
            parserStatus->componentComplete();
        if (const int finalizerCast = loadedType.finalizerCast(); finalizerCast != -1) {
            auto* hook = reinterpret_cast<QQmlFinalizerHook *>(reinterpret_cast<char *>(rv) + finalizerCast);
            hook->componentFinalized();
        }
    }
 
    if (rv) {
        QQmlData *ddata = QQmlData::get(rv);
        Q_ASSERT(ddata);
        // top-level objects should never get JS ownership.
        // if JS ownership is needed this needs to be explicitly undone (like in createObject())
        ddata->indestructible = true;
        ddata->explicitIndestructibleSet = true;
        ddata->rootObjectInCreation = false;
    }
 
    return rv;
}
 
void QQmlComponentPrivate::beginDeferred(QQmlEnginePrivate *enginePriv,
                                                 QObject *object, DeferredState *deferredState)
{
    QQmlData *ddata = QQmlData::get(object);
    Q_ASSERT(!ddata->deferredData.isEmpty());
 
    deferredState->reserve(ddata->deferredData.size());
 
    for (QQmlData::DeferredData *deferredData : std::as_const(ddata->deferredData)) {
        enginePriv->inProgressCreations++;
 
        ConstructionState state;
        state.setCompletePending(true);
 
        auto creator = state.initCreator(
                    deferredData->context->parent(),
                    deferredData->compilationUnit,
                    QQmlRefPointer<QQmlContextData>());
 
        if (!creator->populateDeferredProperties(object, deferredData))
            state.appendCreatorErrors();
        deferredData->bindings.clear();
 
        deferredState->push_back(std::move(state));
    }
}
 
void QQmlComponentPrivate::completeDeferred(QQmlEnginePrivate *enginePriv, QQmlComponentPrivate::DeferredState *deferredState)
{
    for (ConstructionState &state : *deferredState)
        complete(enginePriv, &state);
}
 
void QQmlComponentPrivate::complete(QQmlEnginePrivate *enginePriv, ConstructionState *state)
{
    if (state->isCompletePending()) {
        QQmlInstantiationInterrupt interrupt;
        state->creator()->finalize(interrupt);
 
        state->setCompletePending(false);
 
        enginePriv->inProgressCreations--;
 
        if (0 == enginePriv->inProgressCreations) {
            while (enginePriv->erroredBindings) {
                enginePriv->warning(enginePriv->erroredBindings->removeError());
            }
        }
    }
}
 
QQmlProperty QQmlComponentPrivate::removePropertyFromRequired(
        QObject *createdComponent, const QString &name, RequiredProperties *requiredProperties,
        QQmlEngine *engine, bool *wasInRequiredProperties)
{
    Q_ASSERT(requiredProperties);
    QQmlProperty prop(createdComponent, name, engine);
    auto privProp = QQmlPropertyPrivate::get(prop);
    if (prop.isValid()) {
        // resolve outstanding required properties
        const QQmlPropertyData *targetProp = &privProp->core;
        if (targetProp->isAlias()) {
            auto target = createdComponent;
            QQmlPropertyIndex originalIndex(targetProp->coreIndex());
            QQmlPropertyIndex propIndex;
            QQmlPropertyPrivate::findAliasTarget(target, originalIndex, &target, &propIndex);
            QQmlData *data = QQmlData::get(target);
            Q_ASSERT(data && data->propertyCache);
            targetProp = data->propertyCache->property(propIndex.coreIndex());
        } else {
            // we need to get the pointer from the property cache instead of directly using
            // targetProp else the lookup will fail
            QQmlData *data = QQmlData::get(createdComponent);
            Q_ASSERT(data && data->propertyCache);
            targetProp = data->propertyCache->property(targetProp->coreIndex());
        }
        auto it = requiredProperties->constFind({createdComponent, targetProp});
        if (it != requiredProperties->cend()) {
            if (wasInRequiredProperties)
                *wasInRequiredProperties = true;
            requiredProperties->erase(it);
        } else {
            if (wasInRequiredProperties)
                *wasInRequiredProperties = false;
        }
    }
    return prop;
}
 
void QQmlComponent::completeCreate()
{
    Q_D(QQmlComponent);
 
    d->completeCreate();
}
 
void QQmlComponentPrivate::completeCreate()
{
    if (state.hasUnsetRequiredProperties()) {
        for (const auto& unsetRequiredProperty: std::as_const(*state.requiredProperties())) {
            QQmlError error = unsetRequiredPropertyToQQmlError(unsetRequiredProperty);
            state.errors.push_back(QQmlComponentPrivate::AnnotatedQmlError { error, true });
        }
    }
    if (loadedType.isValid()) {
        /*
           We can directly set completePending to false, as finalize is only concerned
           with setting up pending bindings, but that cannot happen here, as we're
           dealing with a pure C++ type, which cannot have pending bindings
        */
        state.setCompletePending(false);
        QQmlEnginePrivate::get(engine)->inProgressCreations--;
    } else if (state.isCompletePending()) {
        ++creationDepth;
        QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
        complete(ep, &state);
        --creationDepth;
    }
}
 
QQmlComponentAttached::QQmlComponentAttached(QObject *parent)
: QObject(parent), m_prev(nullptr), m_next(nullptr)
{
}
 
QQmlComponentAttached::~QQmlComponentAttached()
{
    if (m_prev) *m_prev = m_next;
    if (m_next) m_next->m_prev = m_prev;
    m_prev = nullptr;
    m_next = nullptr;
}
 
QQmlComponentAttached *QQmlComponent::qmlAttachedProperties(QObject *obj)
{
    QQmlComponentAttached *a = new QQmlComponentAttached(obj);
 
    QQmlEngine *engine = qmlEngine(obj);
    if (!engine)
        return a;
 
    QQmlEnginePrivate *p = QQmlEnginePrivate::get(engine);
    if (p->activeObjectCreator) { // XXX should only be allowed during begin
        a->insertIntoList(p->activeObjectCreator->componentAttachment());
    } else {
        QQmlData *d = QQmlData::get(obj);
        Q_ASSERT(d);
        Q_ASSERT(d->context);
        d->context->addComponentAttached(a);
    }
 
    return a;
}
 
void QQmlComponent::loadFromModule(QAnyStringView uri, QAnyStringView typeName,
                                   QQmlComponent::CompilationMode mode)
{
    Q_D(QQmlComponent);
    auto [status, type] = d->prepareLoadFromModule(uri, typeName);
    d->completeLoadFromModule(uri, typeName, type, status, mode);
}
 
LoadHelper::ResolveTypeResult QQmlComponentPrivate::prepareLoadFromModule(QAnyStringView uri,
                                                                          QAnyStringView typeName)
{
    auto enginePriv = QQmlEnginePrivate::get(engine);
    // LoadHelper must be on the Heap as it derives from QQmlRefCount
    auto loadHelper = QQml::makeRefPointer<LoadHelper>(&enginePriv->typeLoader, uri);
 
    return loadHelper->resolveType(typeName);
}
 
void QQmlComponentPrivate::completeLoadFromModule(QAnyStringView uri, QAnyStringView typeName, QQmlType type,
                                                  LoadHelper::ResolveTypeResult::Status moduleStatus,
                                                  QQmlComponent::CompilationMode mode)
{
    Q_Q(QQmlComponent);
 
    // we always mimic the progressChanged behavior from loadUrl
    auto reportError = [&](QString msg) {
        QQmlError error;
        error.setDescription(msg);
        state.errors.push_back(std::move(error));
        progress = 1;
        emit q->progressChanged(1);
        emit q->statusChanged(q->Error);
    };
    auto emitProgressReset = [&](){
        if (progress != 0) {
            progress = 0;
            emit q->progressChanged(0);
        }
    };
    auto emitComplete = [&]() {
        progress = 1;
        emit q->progressChanged(1);
        emit q->statusChanged(q->status());
    };
    emitProgressReset();
    if (moduleStatus == LoadHelper::ResolveTypeResult::NoSuchModule) {
        reportError(QLatin1String(R"(No module named "%1" found)").arg(uri.toString()));
    } else if (!type.isValid()) {
        reportError(QLatin1String(R"(Module "%1" contains no type named "%2")")
                    .arg(uri.toString(), typeName.toString()));
    } else if (type.isCreatable()) {
        clear();
        loadedType = type;
        emitComplete();
    } else if (type.isComposite()) {
        // loadUrl takes care of signal emission
        loadUrl(type.sourceUrl(), mode);
    } else if (type.isInlineComponentType()) {
        auto baseUrl = type.sourceUrl();
        baseUrl.setFragment(QString());
        {
            // we don't want to emit status changes from the "helper" loadUrl below
            // because it would signal success to early
            QSignalBlocker blockSignals(q);
            // we really need to continue in a synchronous way, otherwise we can't check the CU
            loadUrl(baseUrl, QQmlComponent::PreferSynchronous);
        }
        if (q->isError()) {
            emitComplete();
            return;
        }
        QString elementName = type.elementName();
        if (compilationUnit->inlineComponentId(elementName) == -1) {
            QString realTypeName = typeName.toString();
            realTypeName.truncate(realTypeName.indexOf(u'.'));
            QString errorMessage = R"(Type "%1" from module "%2" contains no inline component named "%3".)"_L1.arg(
                    realTypeName, uri.toString(), elementName);
            if (elementName == u"qml")
                errorMessage += " To load the type \"%1\", drop the \".qml\" extension."_L1.arg(realTypeName);
            reportError(std::move(errorMessage));
        } else {
            inlineComponentName = std::make_unique<QString>(std::move(elementName));
            emitComplete();
        }
    } else if (type.isSingleton() || type.isCompositeSingleton()) {
        reportError(QLatin1String(R"(%1 is a singleton, and cannot be loaded)").arg(typeName.toString()));
    } else {
        reportError(QLatin1String("Could not load %1, as the type is uncreatable").arg(typeName.toString()));
    }
}
 
void QQmlComponent::create(QQmlIncubator &incubator, QQmlContext *context, QQmlContext *forContext)
{
    Q_D(QQmlComponent);
 
    if (!context)
        context = d->engine->rootContext();
 
    QQmlRefPointer<QQmlContextData> contextData = QQmlContextData::get(context);
    QQmlRefPointer<QQmlContextData> forContextData =
            forContext ?  QQmlContextData::get(forContext) : contextData;
 
    if (!contextData->isValid()) {
        qWarning("QQmlComponent: Cannot create a component in an invalid context");
        return;
    }
 
    if (contextData->engine() != d->engine) {
        qWarning("QQmlComponent: Must create component in context from the same QQmlEngine");
        return;
    }
 
    if (!isReady()) {
        qWarning("QQmlComponent: Component is not ready");
        return;
    }
 
    incubator.clear();
    QExplicitlySharedDataPointer<QQmlIncubatorPrivate> p(incubator.d);
 
    if (d->loadedType.isValid()) {
        // there isn't really an incubation process for C++ backed types
        // so just create the object and signal that we are ready
 
        p->incubateCppBasedComponent(this, context);
        return;
    }
 
    QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(d->engine);
 
    p->compilationUnit = d->compilationUnit;
    p->enginePriv = enginePriv;
    p->creator.reset(new QQmlObjectCreator(contextData, d->compilationUnit, d->creationContext, p.data()));
    p->subComponentToCreate = d->start;
 
    enginePriv->incubate(incubator, forContextData);
}
 
void QQmlComponent::setInitialProperties(QObject *component, const QVariantMap &properties)
{
    Q_D(QQmlComponent);
    for (auto it = properties.constBegin(); it != properties.constEnd(); ++it)
        d->setInitialProperty(component, it.key(), it.value());
}
 
/*
    This is essentially a copy of QQmlComponent::create(); except it takes the QQmlContextData
    arguments instead of QQmlContext which means we don't have to construct the rather weighty
    wrapper class for every delegate item.
 
    This is used by QQmlDelegateModel.
*/
void QQmlComponentPrivate::incubateObject(
        QQmlIncubator *incubationTask,
        QQmlComponent *component,
        QQmlEngine *engine,
        const QQmlRefPointer<QQmlContextData> &context,
        const QQmlRefPointer<QQmlContextData> &forContext)
{
    QQmlIncubatorPrivate *incubatorPriv = QQmlIncubatorPrivate::get(incubationTask);
    QQmlEnginePrivate *enginePriv = QQmlEnginePrivate::get(engine);
    QQmlComponentPrivate *componentPriv = QQmlComponentPrivate::get(component);
 
    incubatorPriv->compilationUnit = componentPriv->compilationUnit;
    incubatorPriv->enginePriv = enginePriv;
    incubatorPriv->creator.reset(new QQmlObjectCreator(context, componentPriv->compilationUnit, componentPriv->creationContext));
 
    if (start == -1) {
        if (const QString *icName = componentPriv->inlineComponentName.get()) {
            start = compilationUnit->inlineComponentId(*icName);
            Q_ASSERT(start > 0);
        }
    }
    incubatorPriv->subComponentToCreate = componentPriv->start;
 
    enginePriv->incubate(*incubationTask, forContext);
}
 
 
 
class QQmlComponentIncubator;
 
namespace QV4 {
 
namespace Heap {
 
#define QmlIncubatorObjectMembers(class, Member) \
    Member(class, HeapValue, HeapValue, valuemapOrObject) \
    Member(class, HeapValue, HeapValue, statusChanged) \
    Member(class, Pointer, QmlContext *, qmlContext) \
    Member(class, NoMark, QQmlComponentIncubator *, incubator) \
    Member(class, NoMark, QV4QPointer<QObject>, parent)
 
DECLARE_HEAP_OBJECT(QmlIncubatorObject, Object) {
    DECLARE_MARKOBJECTS(QmlIncubatorObject)
 
    void init(QQmlIncubator::IncubationMode = QQmlIncubator::Asynchronous);
    inline void destroy();
};
 
}
 
struct QmlIncubatorObject : public QV4::Object
{
    V4_OBJECT2(QmlIncubatorObject, Object)
    V4_NEEDS_DESTROY
 
    static ReturnedValue method_get_statusChanged(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
    static ReturnedValue method_set_statusChanged(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
    static ReturnedValue method_get_status(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
    static ReturnedValue method_get_object(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
    static ReturnedValue method_forceCompletion(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
 
    void statusChanged(QQmlIncubator::Status);
    void setInitialState(QObject *, RequiredProperties *requiredProperties);
};
 
}
 
DEFINE_OBJECT_VTABLE(QV4::QmlIncubatorObject);
 
class QQmlComponentIncubator : public QQmlIncubator
{
public:
    QQmlComponentIncubator(QV4::Heap::QmlIncubatorObject *inc, IncubationMode mode)
        : QQmlIncubator(mode)
    {
        incubatorObject.set(inc->internalClass->engine, inc);
    }
 
    void statusChanged(Status s) override {
        QV4::Scope scope(incubatorObject.engine());
        QV4::Scoped<QV4::QmlIncubatorObject> i(scope, incubatorObject.as<QV4::QmlIncubatorObject>());
        i->statusChanged(s);
    }
 
    void setInitialState(QObject *o) override {
        QV4::Scope scope(incubatorObject.engine());
        QV4::Scoped<QV4::QmlIncubatorObject> i(scope, incubatorObject.as<QV4::QmlIncubatorObject>());
        auto d = QQmlIncubatorPrivate::get(this);
        i->setInitialState(o, d->requiredProperties());
    }
 
    QV4::PersistentValue incubatorObject; // keep a strong internal reference while incubating
};
 
 
static void QQmlComponent_setQmlParent(QObject *me, QObject *parent)
{
    if (parent) {
        me->setParent(parent);
        typedef QQmlPrivate::AutoParentFunction APF;
        QList<APF> functions = QQmlMetaType::parentFunctions();
 
        bool needParent = false;
        for (int ii = 0; ii < functions.size(); ++ii) {
            QQmlPrivate::AutoParentResult res = functions.at(ii)(me, parent);
            if (res == QQmlPrivate::Parented) {
                needParent = false;
                break;
            } else if (res == QQmlPrivate::IncompatibleParent) {
                needParent = true;
            }
        }
        if (needParent)
            qmlWarning(me) << "Created graphical object was not placed in the graphics scene.";
    }
}
 
void QQmlComponentPrivate::setInitialProperties(
    QV4::ExecutionEngine *engine, QV4::QmlContext *qmlContext, const QV4::Value &o,
    const QV4::Value &v, RequiredProperties *requiredProperties, QObject *createdComponent,
    QQmlObjectCreator *creator)
{
    QV4::Scope scope(engine);
    QV4::ScopedObject object(scope);
    QV4::ScopedObject valueMap(scope, v);
    QV4::ObjectIterator it(scope, valueMap, QV4::ObjectIterator::EnumerableOnly);
    QV4::ScopedString name(scope);
    QV4::ScopedValue val(scope);
    if (engine->hasException)
        return;
 
    // js modules (mjs) have no qmlContext
    QV4::ScopedStackFrame frame(scope, qmlContext ? qmlContext : engine->scriptContext());
 
    while (1) {
        name = it.nextPropertyNameAsString(val);
        if (!name)
            break;
        object = o;
        const QStringList properties = name->toQString().split(QLatin1Char('.'));
        bool isTopLevelProperty = properties.size() == 1;
        for (int i = 0; i < properties.size() - 1; ++i) {
            name = engine->newString(properties.at(i));
            object = object->get(name);
            if (engine->hasException || !object) {
                break;
            }
        }
        if (engine->hasException) {
            qmlWarning(createdComponent, engine->catchExceptionAsQmlError());
            continue;
        }
        if (!object) {
            QQmlError error;
            error.setUrl(qmlContext ? qmlContext->qmlContext()->url() : QUrl());
            error.setDescription(QLatin1String("Cannot resolve property \"%1\".")
                                 .arg(properties.join(u'.')));
            qmlWarning(createdComponent, error);
            continue;
        }
        const QString lastProperty = properties.last();
        name = engine->newString(lastProperty);
        object->put(name, val);
        if (engine->hasException) {
            qmlWarning(createdComponent, engine->catchExceptionAsQmlError());
            continue;
        } else if (isTopLevelProperty && requiredProperties) {
            auto prop = removePropertyFromRequired(createdComponent, name->toQString(),
                                                   requiredProperties, engine->qmlEngine());
        }
 
        removePendingQPropertyBinding(object, lastProperty, creator);
    }
 
    engine->hasException = false;
}
 
QQmlError QQmlComponentPrivate::unsetRequiredPropertyToQQmlError(const RequiredPropertyInfo &unsetRequiredProperty)
{
    QQmlError error;
    QString description = QLatin1String("Required property %1 was not initialized").arg(unsetRequiredProperty.propertyName);
    switch (unsetRequiredProperty.aliasesToRequired.size()) {
    case 0:
        break;
    case 1: {
        const auto info = unsetRequiredProperty.aliasesToRequired.first();
        description += QLatin1String("\nIt can be set via the alias property %1 from %2\n").arg(info.propertyName, info.fileUrl.toString());
        break;
    }
    default:
        description += QLatin1String("\nIt can be set via one of the following alias properties:");
        for (auto aliasInfo: unsetRequiredProperty.aliasesToRequired) {
            description += QLatin1String("\n- %1 (%2)").arg(aliasInfo.propertyName, aliasInfo.fileUrl.toString());
        }
        description += QLatin1Char('\n');
    }
    error.setDescription(description);
    error.setUrl(unsetRequiredProperty.fileUrl);
    error.setLine(qmlConvertSourceCoordinate<quint32, int>(
            unsetRequiredProperty.location.line()));
    error.setColumn(qmlConvertSourceCoordinate<quint32, int>(
            unsetRequiredProperty.location.column()));
    return  error;
}
 
#if QT_DEPRECATED_SINCE(6, 3)
void QQmlComponent::createObject(QQmlV4FunctionPtr args)
{
    Q_D(QQmlComponent);
    Q_ASSERT(d->engine);
    Q_ASSERT(args);
 
    qmlWarning(this) << "Unsuitable arguments passed to createObject(). The first argument should "
                        "be a QObject* or null, and the second argument should be a JavaScript "
                        "object or a QVariantMap";
 
    QObject *parent = nullptr;
    QV4::ExecutionEngine *v4 = args->v4engine();
    QV4::Scope scope(v4);
    QV4::ScopedValue valuemap(scope, QV4::Value::undefinedValue());
 
    if (args->length() >= 1) {
        QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope, (*args)[0]);
        if (qobjectWrapper)
            parent = qobjectWrapper->object();
    }
 
    if (args->length() >= 2) {
        QV4::ScopedValue v(scope, (*args)[1]);
        if (!v->as<QV4::Object>() || v->as<QV4::ArrayObject>()) {
            qmlWarning(this) << tr("createObject: value is not an object");
            args->setReturnValue(QV4::Encode::null());
            return;
        }
        valuemap = v;
    }
 
    QQmlContext *ctxt = creationContext();
    if (!ctxt) ctxt = d->engine->rootContext();
 
    QObject *rv = beginCreate(ctxt);
 
    if (!rv) {
        args->setReturnValue(QV4::Encode::null());
        return;
    }
 
    QQmlComponent_setQmlParent(rv, parent);
 
    QV4::ScopedValue object(scope, QV4::QObjectWrapper::wrap(v4, rv));
    Q_ASSERT(object->isObject());
 
    if (!valuemap->isUndefined()) {
        QV4::Scoped<QV4::QmlContext> qmlContext(scope, v4->qmlContext());
        QQmlComponentPrivate::setInitialProperties(
            v4, qmlContext, object, valuemap, d->state.requiredProperties(), rv,
            d->state.creator());
    }
    if (d->state.hasUnsetRequiredProperties()) {
        QList<QQmlError> errors;
        for (const auto &requiredProperty: std::as_const(*d->state.requiredProperties())) {
            errors.push_back(QQmlComponentPrivate::unsetRequiredPropertyToQQmlError(requiredProperty));
        }
        qmlWarning(rv, errors);
        args->setReturnValue(QV4::Encode::null());
        delete rv;
        return;
    }
 
    d->completeCreate();
 
    Q_ASSERT(QQmlData::get(rv));
    QQmlData::get(rv)->explicitIndestructibleSet = false;
    QQmlData::get(rv)->indestructible = false;
 
    args->setReturnValue(object->asReturnedValue());
}
#endif
 
QObject *QQmlComponent::createObject(QObject *parent, const QVariantMap &properties)
{
    Q_D(QQmlComponent);
    Q_ASSERT(d->engine);
    QObject *rv = d->createWithProperties(parent, properties, creationContext(),
                                          QQmlComponentPrivate::CreateWarnAboutRequiredProperties);
    if (rv) {
        QQmlData *qmlData = QQmlData::get(rv);
        Q_ASSERT(qmlData);
        qmlData->explicitIndestructibleSet = false;
        qmlData->indestructible = false;
    }
    return rv;
}
 
void QQmlComponent::incubateObject(QQmlV4FunctionPtr args)
{
    Q_D(QQmlComponent);
    Q_ASSERT(d->engine);
    Q_UNUSED(d);
    Q_ASSERT(args);
    QV4::ExecutionEngine *v4 = args->v4engine();
    QV4::Scope scope(v4);
 
    QObject *parent = nullptr;
    QV4::ScopedValue valuemap(scope, QV4::Value::undefinedValue());
    QQmlIncubator::IncubationMode mode = QQmlIncubator::Asynchronous;
 
    if (args->length() >= 1) {
        QV4::Scoped<QV4::QObjectWrapper> qobjectWrapper(scope, (*args)[0]);
        if (qobjectWrapper)
            parent = qobjectWrapper->object();
    }
 
    if (args->length() >= 2) {
        QV4::ScopedValue v(scope, (*args)[1]);
        if (v->isNull()) {
        } else if (!v->as<QV4::Object>() || v->as<QV4::ArrayObject>()) {
            qmlWarning(this) << tr("createObject: value is not an object");
            args->setReturnValue(QV4::Encode::null());
            return;
        } else {
            valuemap = v;
        }
    }
 
    if (args->length() >= 3) {
        QV4::ScopedValue val(scope, (*args)[2]);
        quint32 v = val->toUInt32();
        if (v == 0)
            mode = QQmlIncubator::Asynchronous;
        else if (v == 1)
            mode = QQmlIncubator::AsynchronousIfNested;
    }
 
    QQmlComponentExtension *e = componentExtension(args->v4engine());
 
    QV4::Scoped<QV4::QmlIncubatorObject> r(scope, v4->memoryManager->allocate<QV4::QmlIncubatorObject>(mode));
    QV4::ScopedObject p(scope, e->incubationProto.value());
    r->setPrototypeOf(p);
 
    if (!valuemap->isUndefined())
        r->d()->valuemapOrObject.set(scope.engine, valuemap);
    r->d()->qmlContext.set(scope.engine, v4->qmlContext());
    r->d()->parent = parent;
 
    QQmlIncubator *incubator = r->d()->incubator;
    create(*incubator, creationContext());
 
    if (incubator->status() == QQmlIncubator::Null) {
        args->setReturnValue(QV4::Encode::null());
    } else {
        args->setReturnValue(r.asReturnedValue());
    }
}
 
// XXX used by QSGLoader
void QQmlComponentPrivate::initializeObjectWithInitialProperties(QV4::QmlContext *qmlContext, const QV4::Value &valuemap, QObject *toCreate, RequiredProperties *requiredProperties)
{
    QV4::ExecutionEngine *v4engine = engine->handle();
    QV4::Scope scope(v4engine);
 
    QV4::ScopedValue object(scope, QV4::QObjectWrapper::wrap(v4engine, toCreate));
    Q_ASSERT(object->as<QV4::Object>());
 
    if (!valuemap.isUndefined()) {
        setInitialProperties(
            v4engine, qmlContext, object, valuemap, requiredProperties, toCreate, state.creator());
    }
}
 
QQmlComponentExtension::QQmlComponentExtension(QV4::ExecutionEngine *v4)
{
    QV4::Scope scope(v4);
    QV4::ScopedObject proto(scope, v4->newObject());
    proto->defineAccessorProperty(QStringLiteral("onStatusChanged"),
                                  QV4::QmlIncubatorObject::method_get_statusChanged, QV4::QmlIncubatorObject::method_set_statusChanged);
    proto->defineAccessorProperty(QStringLiteral("status"), QV4::QmlIncubatorObject::method_get_status, nullptr);
    proto->defineAccessorProperty(QStringLiteral("object"), QV4::QmlIncubatorObject::method_get_object, nullptr);
    proto->defineDefaultProperty(QStringLiteral("forceCompletion"), QV4::QmlIncubatorObject::method_forceCompletion);
 
    incubationProto.set(v4, proto);
}
 
QV4::ReturnedValue QV4::QmlIncubatorObject::method_get_object(const FunctionObject *b, const Value *thisObject, const Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QmlIncubatorObject> o(scope, thisObject->as<QmlIncubatorObject>());
    if (!o)
        THROW_TYPE_ERROR();
 
    return QV4::QObjectWrapper::wrap(scope.engine, o->d()->incubator->object());
}
 
QV4::ReturnedValue QV4::QmlIncubatorObject::method_forceCompletion(const FunctionObject *b, const Value *thisObject, const Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QmlIncubatorObject> o(scope, thisObject->as<QmlIncubatorObject>());
    if (!o)
        THROW_TYPE_ERROR();
 
    o->d()->incubator->forceCompletion();
 
    RETURN_UNDEFINED();
}
 
QV4::ReturnedValue QV4::QmlIncubatorObject::method_get_status(const FunctionObject *b, const Value *thisObject, const Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QmlIncubatorObject> o(scope, thisObject->as<QmlIncubatorObject>());
    if (!o)
        THROW_TYPE_ERROR();
 
    return QV4::Encode(o->d()->incubator->status());
}
 
QV4::ReturnedValue QV4::QmlIncubatorObject::method_get_statusChanged(const FunctionObject *b, const Value *thisObject, const Value *, int)
{
    QV4::Scope scope(b);
    QV4::Scoped<QmlIncubatorObject> o(scope, thisObject->as<QmlIncubatorObject>());
    if (!o)
        THROW_TYPE_ERROR();
 
    return QV4::Encode(o->d()->statusChanged);
}
 
QV4::ReturnedValue QV4::QmlIncubatorObject::method_set_statusChanged(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    QV4::Scoped<QmlIncubatorObject> o(scope, thisObject->as<QmlIncubatorObject>());
    if (!o || argc < 1)
        THROW_TYPE_ERROR();
 
    o->d()->statusChanged.set(scope.engine, argv[0]);
 
    RETURN_UNDEFINED();
}
 
QQmlComponentExtension::~QQmlComponentExtension()
{
}
 
void QV4::Heap::QmlIncubatorObject::init(QQmlIncubator::IncubationMode m)
{
    Object::init();
    valuemapOrObject.set(internalClass->engine, QV4::Value::undefinedValue());
    statusChanged.set(internalClass->engine, QV4::Value::undefinedValue());
    parent.init();
    qmlContext.set(internalClass->engine, nullptr);
    incubator = new QQmlComponentIncubator(this, m);
}
 
void QV4::Heap::QmlIncubatorObject::destroy() {
    delete incubator;
    parent.destroy();
    Object::destroy();
}
 
void QV4::QmlIncubatorObject::setInitialState(QObject *o, RequiredProperties *requiredProperties)
{
    QQmlComponent_setQmlParent(o, d()->parent);
 
    if (!d()->valuemapOrObject.isUndefined()) {
        QV4::ExecutionEngine *v4 = engine();
        QV4::Scope scope(v4);
        QV4::ScopedObject obj(scope, QV4::QObjectWrapper::wrap(v4, o));
        QV4::Scoped<QV4::QmlContext> qmlCtxt(scope, d()->qmlContext);
        QQmlComponentPrivate::setInitialProperties(
            v4, qmlCtxt, obj, d()->valuemapOrObject, requiredProperties, o,
            QQmlIncubatorPrivate::get(d()->incubator)->creator.data());
    }
}
 
void QV4::QmlIncubatorObject::statusChanged(QQmlIncubator::Status s)
{
    QV4::Scope scope(engine());
 
    QObject *object = d()->incubator->object();
 
    if (s == QQmlIncubator::Ready) {
        // We don't need the arguments anymore, but we still want to hold on to the object so
        // that it doesn't get gc'd
        d()->valuemapOrObject.set(scope.engine, QV4::QObjectWrapper::wrap(scope.engine, object));
 
        QQmlData *ddata = QQmlData::get(object);
        Q_ASSERT(ddata);
        ddata->explicitIndestructibleSet = false;
        ddata->indestructible = false;
    }
 
    QV4::ScopedFunctionObject f(scope, d()->statusChanged);
    if (f) {
        QV4::JSCallArguments jsCallData(scope, 1);
        *jsCallData.thisObject = this;
        jsCallData.args[0] = QV4::Value::fromUInt32(s);
        f->call(jsCallData);
        if (scope.hasException()) {
            QQmlError error = scope.engine->catchExceptionAsQmlError();
            QQmlEnginePrivate::warning(QQmlEnginePrivate::get(scope.engine->qmlEngine()), error);
        }
    }
 
    if (s != QQmlIncubator::Loading)
        d()->incubator->incubatorObject.clear();
}
 
#undef INITIALPROPERTIES_SOURCE
 
QT_END_NAMESPACE
 
#include "moc_qqmlcomponent.cpp"
#include "moc_qqmlcomponentattached_p.cpp"