qv4qobjectwrapper_p.h

qt/qtdeclarative/src/qml/jsruntime/qv4qobjectwrapper_p.h

Enable keyboard shortcuts

Revision control

Copy as Markdown

// 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

// Qt-Security score:significant

#ifndef QV4QOBJECTWRAPPER_P_H

#define QV4QOBJECTWRAPPER_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include <private/qbipointer_p.h>

#include <private/qintrusivelist_p.h>

#include <private/qqmldata_p.h>

#include <private/qv4functionobject_p.h>

#include <private/qv4lookup_p.h>

#include <private/qv4value_p.h>

#include <QtCore/qglobal.h>

#include <QtCore/qmetatype.h>

#include <QtCore/qhash.h>

#include <utility>

QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(lcBuiltinsBindingRemoval)

class QObject;

class QQmlData;

class QQmlPropertyCache;

class QQmlPropertyData;

class QQmlObjectOrGadget;

namespace QV4 {

struct QObjectSlotDispatcher;

namespace Heap {

struct QQmlValueTypeWrapper;

struct Q_QML_EXPORT QObjectWrapper : Object {

    void init(QObject *object)

        Object::init();

        qObj.init(object);

    void destroy() {

        qObj.destroy();

        Object::destroy();

    QObject *object() const { return qObj.data(); }

    static void markObjects(Heap::Base *that, MarkStack *markStack);

private:

    QV4QPointer<QObject> qObj;

};

#define QObjectMethodMembers(class, Member) \

    Member(class, Pointer, Object *, wrapper) \

DECLARE_EXPORTED_HEAP_OBJECT(QObjectMethod, FunctionObject) {

    DECLARE_MARKOBJECTS(QObjectMethod)

    QQmlPropertyData *methods;

    alignas(alignof(QQmlPropertyData)) std::byte _singleMethod[sizeof(QQmlPropertyData)];

    int methodCount;

    int index;

    void init(QV4::ExecutionEngine *engine, Object *wrapper, int index);

    void destroy()

        if (methods != reinterpret_cast<const QQmlPropertyData *>(&_singleMethod))

            delete[] methods;

        FunctionObject::destroy();

    void ensureMethodsCache(const QMetaObject *thisMeta);

    QString name() const;

    const QMetaObject *metaObject() const;

    QObject *object() const;

    bool isDetached() const;

    bool isAttachedTo(QObject *o) const;

    enum ThisObjectMode {

        Invalid,

        Included,

        Explicit,

};

    QV4::Heap::QObjectMethod::ThisObjectMode checkThisObject(const QMetaObject *thisMeta) const;

};

struct QmlSignalHandler : Object {

    void init(QObject *object, int signalIndex);

    void destroy() {

        qObj.destroy();

        Object::destroy();

    int signalIndex;

    QObject *object() const { return qObj.data(); }

    void setObject(QObject *o) { qObj = o; }

private:

    QV4QPointer<QObject> qObj;

};

struct Q_QML_EXPORT QObjectWrapper : public Object

    V4_OBJECT2(QObjectWrapper, Object)

    Q_MANAGED_TYPE(V4QObjectWrapper)

    V4_NEEDS_DESTROY

    enum Flag {

        NoFlag         = 0x0,

        CheckRevision  = 0x1,

        AttachMethods   = 0x2,

        AllowOverride  = 0x4,

        IncludeImports = 0x8,

};

    Q_DECLARE_FLAGS(Flags, Flag);

    static void initializeBindings(ExecutionEngine *engine);

    const QMetaObject *metaObject() const

        if (QObject *o = object())

            return o->metaObject();

        return nullptr;

    QObject *object() const { return d()->object(); }

    ReturnedValue getQmlProperty(

            const QQmlRefPointer<QQmlContextData> &qmlContext, String *name,

            Flags flags, bool *hasProperty = nullptr) const;

    static ReturnedValue getQmlProperty(

            ExecutionEngine *engine, const QQmlRefPointer<QQmlContextData> &qmlContext,

            Heap::Object *wrapper, QObject *object, String *name, Flags flags,

            bool *hasProperty = nullptr, const QQmlPropertyData **property = nullptr);

    static bool setQmlProperty(

            ExecutionEngine *engine, const QQmlRefPointer<QQmlContextData> &qmlContext,

            QObject *object, String *name, Flags flags, const Value &value);

    Q_NODISCARD_X("Use ensureWrapper if you don't need the return value")

    static ReturnedValue wrap(ExecutionEngine *engine, QObject *object);

    Q_NODISCARD_X("Throwing the const wrapper away can cause it to be garbage collected")

    static ReturnedValue wrapConst(ExecutionEngine *engine, QObject *object);

    static void ensureWrapper(ExecutionEngine *engine, QObject *object);

    static void markWrapper(QObject *object, MarkStack *markStack);

    using Object::get;

    static void setProperty(ExecutionEngine *engine, QObject *object, int propertyIndex, const Value &value);

    void setProperty(ExecutionEngine *engine, int propertyIndex, const Value &value);

    static void setProperty(

            ExecutionEngine *engine, QObject *object,

            const QQmlPropertyData *property, const Value &value);

    void destroyObject(bool lastCall);

    static ReturnedValue getProperty(

            ExecutionEngine *engine, Heap::Object *wrapper, QObject *object,

            const QQmlPropertyData *property, Flags flags);

    static ReturnedValue virtualResolveLookupGetter(const Object *object, ExecutionEngine *engine, Lookup *lookup);

    template <typename ReversalFunctor> static ReturnedValue lookupPropertyGetterImpl(

            Lookup *l, ExecutionEngine *engine, const Value &object,

            Flags flags, ReversalFunctor revert);

    template <typename ReversalFunctor> static ReturnedValue lookupMethodGetterImpl(

            Lookup *l, ExecutionEngine *engine, const Value &object,

            Flags flags, ReversalFunctor revert);

    static bool virtualResolveLookupSetter(

            Object *object, ExecutionEngine *engine, Lookup *lookup, const Value &value);

    static OwnPropertyKeyIterator *virtualOwnPropertyKeys(const Object *m, Value *target);

    static int virtualMetacall(Object *object, QMetaObject::Call call, int index, void **a);

    static QString objectToString(

            ExecutionEngine *engine, const QMetaObject *metaObject, QObject *object);

protected:

    static bool virtualIsEqualTo(Managed *that, Managed *o);

    static ReturnedValue create(ExecutionEngine *engine, QObject *object);

    static const QQmlPropertyData *findProperty(

            QObject *o, const QQmlRefPointer<QQmlContextData> &qmlContext,

            String *name, Flags flags, QQmlPropertyData *local);

    const QQmlPropertyData *findProperty(

            const QQmlRefPointer<QQmlContextData> &qmlContext,

            String *name, Flags flags, QQmlPropertyData *local) const;

    static ReturnedValue virtualGet(

            const Managed *m, PropertyKey id, const Value *receiver, bool *hasProperty);

    static bool virtualPut(Managed *m, PropertyKey id, const Value &value, Value *receiver);

    static PropertyAttributes virtualGetOwnProperty(const Managed *m, PropertyKey id, Property *p);

    static ReturnedValue method_connect(

            const FunctionObject *, const Value *thisObject, const Value *argv, int argc);

    static ReturnedValue method_disconnect(

            const FunctionObject *, const Value *thisObject, const Value *argv, int argc);

private:

    Q_NEVER_INLINE static ReturnedValue wrap_slowPath(ExecutionEngine *engine, QObject *object);

    Q_NEVER_INLINE static ReturnedValue wrapConst_slowPath(ExecutionEngine *engine, QObject *object);

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QObjectWrapper::Flags)

// We generally musn't pass ReturnedValue as arguments to other functions.

// In this case, we do it solely for marking purposes so it's fine.

inline void markIfPastMarkWeakValues(ExecutionEngine *engine, ReturnedValue rv)

    const auto gcState = engine->memoryManager->gcStateMachine->state;

    if (gcState != GCStateMachine::Invalid && gcState >= GCState::MarkWeakValues) {

        QV4::WriteBarrier::markCustom(engine, [rv](QV4::MarkStack *ms) {

            auto *m = StaticValue::fromReturnedValue(rv).m();

            m->mark(ms);

});

inline ReturnedValue QObjectWrapper::wrap(ExecutionEngine *engine, QObject *object)

    if (Q_UNLIKELY(QQmlData::wasDeleted(object)))

        return QV4::Encode::null();

    auto ddata = QQmlData::get(object);

    if (Q_LIKELY(ddata && ddata->jsEngineId == engine->m_engineId && !ddata->jsWrapper.isUndefined())) {

        // We own the JS object

        return ddata->jsWrapper.value();

    const auto rv = wrap_slowPath(engine, object);

    markIfPastMarkWeakValues(engine, rv);

    return rv;

// Unfortunately we still need a non-const QObject* here because QQmlData needs to register itself in QObjectPrivate.

inline ReturnedValue QObjectWrapper::wrapConst(ExecutionEngine *engine, QObject *object)

    if (Q_UNLIKELY(QQmlData::wasDeleted(object)))

        return QV4::Encode::null();

    const auto rv = wrapConst_slowPath(engine, object);

    markIfPastMarkWeakValues(engine, rv);

    return rv;

inline bool canConvert(const QQmlPropertyCache *fromMo, const QQmlPropertyCache *toMo)

    while (fromMo) {

        if (fromMo == toMo)

            return true;

        fromMo = fromMo->parent().data();

    return false;

template <typename ReversalFunctor>

inline ReturnedValue QObjectWrapper::lookupPropertyGetterImpl(

        Lookup *lookup, ExecutionEngine *engine, const Value &object,

        QObjectWrapper::Flags flags, ReversalFunctor revertLookup)

    // we can safely cast to a QV4::Object here. If object is something else,

    // the internal class won't match

    Heap::Object *o = static_cast<Heap::Object *>(object.heapObject());

    if (!o || o->internalClass != lookup->qobjectLookup.ic)

        return revertLookup();

    Heap::QObjectWrapper *This = static_cast<Heap::QObjectWrapper *>(o);

    QObject *qobj = This->object();

    if (QQmlData::wasDeleted(qobj))

        return QV4::Encode::undefined();

    QQmlData *ddata = QQmlData::get(qobj, /*create*/false);

    if (!ddata)

        return revertLookup();

    const QQmlPropertyData *property = lookup->qobjectLookup.propertyData;

    if (ddata->propertyCache.data() != lookup->qobjectLookup.propertyCache) {

        // If the property is overridden and the lookup allows overrides to be considered,

        // we have to revert here and redo the lookup from scratch.

        if (property->isOverridden()

                && ((flags & AllowOverride)

                    || property->isFunction()

                    || property->isSignalHandler())) {

            return revertLookup();

        if (!canConvert(ddata->propertyCache.data(), lookup->qobjectLookup.propertyCache))

            return revertLookup();

    return getProperty(engine, This, qobj, property, flags);

template <typename ReversalFunctor>

inline ReturnedValue QObjectWrapper::lookupMethodGetterImpl(

        Lookup *lookup, ExecutionEngine *engine, const Value &object,

        QObjectWrapper::Flags flags, ReversalFunctor revertLookup)

    // we can safely cast to a QV4::Object here. If object is something else,

    // the internal class won't match

    Heap::Object *o = static_cast<Heap::Object *>(object.heapObject());

    if (!o || o->internalClass != lookup->qobjectMethodLookup.ic)

        return revertLookup();

    Heap::QObjectWrapper *This = static_cast<Heap::QObjectWrapper *>(o);

    QObject *qobj = This->object();

    if (QQmlData::wasDeleted(qobj))

        return QV4::Encode::undefined();

    QQmlData *ddata = QQmlData::get(qobj, /*create*/false);

    if (!ddata)

        return revertLookup();

    const QQmlPropertyData *property = lookup->qobjectMethodLookup.propertyData;

    if (ddata->propertyCache.data() != lookup->qobjectMethodLookup.propertyCache) {

        if (property && property->isOverridden())

            return revertLookup();

        if (!canConvert(ddata->propertyCache.data(), lookup->qobjectMethodLookup.propertyCache))

            return revertLookup();

    if (Heap::QObjectMethod *method = lookup->qobjectMethodLookup.method) {

        if (method->isDetached())

            return method->asReturnedValue();

    if (!property) // was toString() or destroy()

        return revertLookup();

    QV4::Scope scope(engine);

    QV4::ScopedValue v(scope, getProperty(engine, This, qobj, property, flags));

    if (!v->as<QObjectMethod>())

        return revertLookup();

    lookup->qobjectMethodLookup.method.set(engine, static_cast<Heap::QObjectMethod *>(v->heapObject()));

    return v->asReturnedValue();

struct QQmlValueTypeWrapper;

struct Q_QML_EXPORT QObjectMethod : public QV4::FunctionObject

    V4_OBJECT2(QObjectMethod, QV4::FunctionObject)

    V4_NEEDS_DESTROY

    enum { DestroyMethod = -1, ToStringMethod = -2 };

    static ReturnedValue create(ExecutionEngine *engine, Heap::Object *wrapper, int index);

    static ReturnedValue create(

            ExecutionEngine *engine, Heap::QQmlValueTypeWrapper *valueType, int index);

    static ReturnedValue create(

            ExecutionEngine *engine, Heap::QObjectMethod *cloneFrom,

            Heap::Object *wrapper, Heap::Object *object);

    int methodIndex() const { return d()->index; }

    QObject *object() const { return d()->object(); }

    QV4::ReturnedValue method_toString(QV4::ExecutionEngine *engine, QObject *o) const;

    QV4::ReturnedValue method_destroy(

            QV4::ExecutionEngine *ctx, QObject *o, const Value *args, int argc) const;

    bool method_destroy(

            QV4::ExecutionEngine *engine, QObject *o, int delay) const;

    static ReturnedValue virtualCall(

            const FunctionObject *, const Value *thisObject, const Value *argv, int argc);

    static void virtualCallWithMetaTypes(

            const FunctionObject *m, QObject *thisObject,

            void **argv, const QMetaType *types, int argc);

    ReturnedValue callInternal(

            const Value *thisObject, const Value *argv, int argc) const;

    void callInternalWithMetaTypes(

            QObject *thisObject, void **argv, const QMetaType *types, int argc) const;

    static std::pair<QObject *, int> extractQtMethod(const QV4::FunctionObject *function);

    static bool isExactMatch(

            const QMetaMethod &method, void **argv, int argc, const QMetaType *types);

private:

    friend struct QMetaObjectWrapper;

    static const QQmlPropertyData *resolveOverloaded(

            const QQmlObjectOrGadget &object, const QQmlPropertyData *methods, int methodCount,

            ExecutionEngine *engine, CallData *callArgs);

    static const QQmlPropertyData *resolveOverloaded(

            const QQmlPropertyData *methods, int methodCount,

            void **argv, int argc, const QMetaType *types);

    static ReturnedValue callPrecise(

            const QQmlObjectOrGadget &object, const QQmlPropertyData &data,

            ExecutionEngine *engine, CallData *callArgs,

            QMetaObject::Call callType = QMetaObject::InvokeMetaMethod);

};

struct Q_QML_EXPORT QmlSignalHandler : public QV4::Object

    V4_OBJECT2(QmlSignalHandler, QV4::Object)

    V4_PROTOTYPE(signalHandlerPrototype)

    V4_NEEDS_DESTROY

    int signalIndex() const { return d()->signalIndex; }

    QObject *object() const { return d()->object(); }

    ReturnedValue call(const Value *thisObject, const Value *argv, int argc) const;

    static void initProto(ExecutionEngine *v4);

};

using QObjectBiPointer = QBiPointer<QObject, const QObject>;

class MultiplyWrappedQObjectMap : public QObject,

                                  private QHash<QObjectBiPointer, QV4::WeakValue>

    Q_OBJECT

public:

    typedef QHash<QObjectBiPointer, QV4::WeakValue>::ConstIterator ConstIterator;

    typedef QHash<QObjectBiPointer, QV4::WeakValue>::Iterator Iterator;

    using value_type = QHash<QObjectBiPointer, QV4::WeakValue>::value_type;

    ConstIterator begin() const { return QHash<QObjectBiPointer, QV4::WeakValue>::constBegin(); }

    Iterator begin() { return QHash<QObjectBiPointer, QV4::WeakValue>::begin(); }

    ConstIterator end() const { return QHash<QObjectBiPointer, QV4::WeakValue>::constEnd(); }

    Iterator end() { return QHash<QObjectBiPointer, QV4::WeakValue>::end(); }

    template<typename Pointer>

    void insert(Pointer key, Heap::Object *value)

        QHash<QObjectBiPointer, WeakValue>::operator[](key).set(value->internalClass->engine, value);

        connect(key, SIGNAL(destroyed(QObject*)), this, SLOT(removeDestroyedObject(QObject*)));

    template<typename Pointer>

    ReturnedValue value(Pointer key) const

        ConstIterator it = find(key);

        return it == end()

                ? QV4::WeakValue().value()

                : it->value();

    Iterator erase(Iterator it);

    template<typename Pointer>

    void remove(Pointer key)

        Iterator it = find(key);

        if (it == end())

            return;

        erase(it);

    template<typename Pointer>

    void mark(Pointer key, MarkStack *markStack)

        Iterator it = find(key);

        if (it == end())

            return;

        it->markOnce(markStack);

private Q_SLOTS:

    void removeDestroyedObject(QObject*);

};

QT_END_NAMESPACE

#endif // QV4QOBJECTWRAPPER_P_H