diff options
Diffstat (limited to 'src/qml/jsruntime/qv4qmlcontext.cpp')
| -rw-r--r-- | src/qml/jsruntime/qv4qmlcontext.cpp | 404 |
1 files changed, 254 insertions, 150 deletions
diff --git a/src/qml/jsruntime/qv4qmlcontext.cpp b/src/qml/jsruntime/qv4qmlcontext.cpp index 5581ea9a53..53444cddb7 100644 --- a/src/qml/jsruntime/qv4qmlcontext.cpp +++ b/src/qml/jsruntime/qv4qmlcontext.cpp @@ -1,61 +1,26 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtQml module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// 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 "qv4qmlcontext_p.h" -#include <private/qqmlengine_p.h> +#include <private/qjsvalue_p.h> #include <private/qqmlcontext_p.h> - +#include <private/qqmlengine_p.h> +#include <private/qqmlglobal_p.h> +#include <private/qqmljavascriptexpression_p.h> +#include <private/qqmllistwrapper_p.h> +#include <private/qqmltypewrapper_p.h> +#include <private/qv4compileddata_p.h> #include <private/qv4engine_p.h> -#include <private/qv4value_p.h> -#include <private/qv4objectproto_p.h> -#include <private/qv4mm_p.h> #include <private/qv4function_p.h> -#include <private/qv4compileddata_p.h> -#include <private/qqmltypewrapper_p.h> -#include <private/qqmllistwrapper_p.h> -#include <private/qqmljavascriptexpression_p.h> -#include <private/qjsvalue_p.h> -#include <private/qv4qobjectwrapper_p.h> -#include <private/qv4module_p.h> -#include <private/qv4lookup_p.h> #include <private/qv4identifiertable_p.h> +#include <private/qv4lookup_p.h> +#include <private/qv4mm_p.h> +#include <private/qv4module_p.h> +#include <private/qv4objectproto_p.h> +#include <private/qv4qobjectwrapper_p.h> +#include <private/qv4stackframe_p.h> +#include <private/qv4value_p.h> #include <QtCore/qloggingcategory.h> @@ -88,11 +53,7 @@ static OptionalReturnedValue searchContextProperties( bool *hasProperty, Value *base, QV4::Lookup *lookup, QV4::Lookup *originalLookup, QQmlEnginePrivate *ep) { - const QV4::IdentifierHash &properties = context->propertyNames(); - if (properties.count() == 0) - return OptionalReturnedValue(); - - const int propertyIdx = properties.value(name); + const int propertyIdx = context->propertyIndex(name); if (propertyIdx == -1) return OptionalReturnedValue(); @@ -126,11 +87,30 @@ static OptionalReturnedValue searchContextProperties( QQmlListProperty<QObject> prop(context->asQQmlContext(), (void*) qintptr(propertyIdx), QQmlContextPrivate::context_count, QQmlContextPrivate::context_at); - return OptionalReturnedValue(QmlListWrapper::create(v4, prop, qMetaTypeId<QQmlListProperty<QObject> >())); + return OptionalReturnedValue(QmlListWrapper::create(v4, prop, QMetaType::fromType<QQmlListProperty<QObject> >())); } return OptionalReturnedValue(v4->fromVariant(cp->propertyValue(propertyIdx))); } +template<typename Lookup> +bool performLookup(ScopedValue *result, bool *hasProperty, const Lookup &lookup) { + bool hasProp = false; + *result = lookup(&hasProp); + if (hasProp) { + if (hasProperty) + *hasProperty = hasProp; + return true; + } + return false; +} + +static QV4::QObjectWrapper::Flags getQmlPropertyFlags(const Lookup *l) +{ + return (l && l->forCall) + ? QV4::QObjectWrapper::CheckRevision + : (QV4::QObjectWrapper::CheckRevision | QV4::QObjectWrapper::AttachMethods); +} + ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *resource, PropertyKey id, const Value *receiver, bool *hasProperty, Value *base, Lookup *lookup) { if (!id.isString()) @@ -154,13 +134,7 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r return Object::virtualGet(resource, id, receiver, hasProperty); } - bool hasProp = false; - ScopedValue result(scope, Object::virtualGet(resource, id, receiver, &hasProp)); - if (hasProp) { - if (hasProperty) - *hasProperty = hasProp; - return result->asReturnedValue(); - } + ScopedValue result(scope); // It's possible we could delay the calculation of the "actual" context (in the case // of sub contexts) until it is definitely needed. @@ -185,17 +159,20 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r ScopedString name(scope, id.asStringOrSymbol()); - const auto performGobalLookUp = [&result, v4, &name, hasProperty]() { - bool hasProp = false; - result = v4->globalObject->get(name, &hasProp); - if (hasProp) { - if (hasProperty) - *hasProperty = hasProp; - return true; - } - return false; + const auto globalLookup = [v4, &name](bool *hasProp) { + return v4->globalObject->get(name, hasProp); }; + const auto jsLookup = [resource, &id, receiver](bool *hasProp) { + return Object::virtualGet(resource, id, receiver, hasProp); + }; + + const bool isJSContext = context->isJSContext(); + + // Do the generic JS lookup early in case of a JavaScript context. + if (isJSContext && performLookup(&result, hasProperty, jsLookup)) + return result->asReturnedValue(); + // If the scope object is a QAbstractDynamicMetaObject, then QMetaObject::indexOfProperty // will call createProperty() on the QADMO and implicitly create the property. While that // is questionable behavior, there are two use-cases that we support in the light of this: @@ -210,16 +187,21 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r // // Note: The scope object is only a QADMO for example when somebody registers a QQmlPropertyMap // sub-class as QML type and then instantiates it in .qml. - if (scopeObject && QQmlPropertyCache::isDynamicMetaObject(scopeObject->metaObject())) { + const QMetaObjectPrivate *metaObjectPrivate = scopeObject + ? reinterpret_cast<const QMetaObjectPrivate *>(scopeObject->metaObject()->d.data) + : nullptr; + if (metaObjectPrivate && metaObjectPrivate->flags & DynamicMetaObject) { // all bets are off, so don't try to optimize any lookups lookup = nullptr; - if (performGobalLookUp()) + if (performLookup(&result, hasProperty, globalLookup)) return result->asReturnedValue(); } - if (context->imports() && name->startsWithUpper()) { + QQmlEnginePrivate *ep = QQmlEnginePrivate::get(v4->qmlEngine()); + if (context->imports() && (name->startsWithUpper() || context->valueTypesAreAddressable())) { // Search for attached properties, enums and imported scripts - QQmlTypeNameCache::Result r = context->imports()->query(name, QQmlImport::AllowRecursion); + QQmlTypeNameCache::Result r = context->imports()->query<QQmlImport::AllowRecursion>( + name, QQmlTypeLoader::get(ep)); if (r.isValid()) { if (hasProperty) @@ -236,14 +218,15 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r return QV4::Encode::null(); } else if (r.type.isValid()) { if (lookup) { + bool isValueSingleton = false; if (r.type.isSingleton()) { QQmlEnginePrivate *e = QQmlEnginePrivate::get(v4->qmlEngine()); if (r.type.isQObjectSingleton() || r.type.isCompositeSingleton()) { e->singletonInstance<QObject*>(r.type); - lookup->qmlContextSingletonLookup.singletonObject = + lookup->qmlContextSingletonLookup.singletonObject.set(v4, Value::fromReturnedValue( QQmlTypeWrapper::create(v4, nullptr, r.type) - ).heapObject(); + ).heapObject()); } else { QJSValue singleton = e->singletonInstance<QJSValue>(r.type); @@ -252,12 +235,14 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r Q_ASSERT(!QJSValuePrivate::asQString(&singleton)); if (QV4::Value *val = QJSValuePrivate::takeManagedValue(&singleton)) { - lookup->qmlContextSingletonLookup.singletonObject = val->heapObject(); + lookup->qmlContextSingletonLookup.singletonObject.set(v4, val->heapObject()); } else { lookup->qmlContextSingletonLookup.singletonValue = QJSValuePrivate::asReturnedValue(&singleton); + isValueSingleton = true; } } - lookup->qmlContextPropertyGetter = QQmlContextWrapper::lookupSingleton; + lookup->qmlContextPropertyGetter = isValueSingleton ? QQmlContextWrapper::lookupValueSingleton + : QQmlContextWrapper::lookupSingleton; return lookup->qmlContextPropertyGetter(lookup, v4, base); } } @@ -266,7 +251,7 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r result = QQmlTypeWrapper::create(v4, scopeObject, context->imports(), r.importNamespace); } if (lookup) { - lookup->qmlTypeLookup.qmlTypeWrapper = static_cast<Heap::Object*>(result->heapObject()); + lookup->qmlTypeLookup.qmlTypeWrapper.set(v4, result->heapObject()); lookup->qmlContextPropertyGetter = QQmlContextWrapper::lookupType; } return result->asReturnedValue(); @@ -275,7 +260,6 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r // Fall through } - QQmlEnginePrivate *ep = QQmlEnginePrivate::get(v4->qmlEngine()); Lookup * const originalLookup = lookup; decltype(lookup->qmlContextPropertyGetter) contextGetterFunction = QQmlContextWrapper::lookupContextObjectProperty; @@ -286,33 +270,69 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r contextGetterFunction = QQmlContextWrapper::lookupScopeObjectProperty; } + QQmlRefPointer<QQmlContextData> outer = context; while (context) { - if (auto property = searchContextProperties(v4, context, name, hasProperty, base, lookup, originalLookup, ep)) - return *property; + if (outer == context) { + if (auto property = searchContextProperties( + v4, context, name, hasProperty, base, lookup, originalLookup, ep)) { + return *property; + } + + outer = outer->parent(); + + if (const auto cu = context->typeCompilationUnit(); cu && cu->componentsAreBound()) { + // If components are bound in this CU, we can search the whole context hierarchy + // of the file. Bound components' contexts override their local properties. + // You also can't instantiate bound components outside of their creation + // context. Therefore this is safe. + + for (; + outer && outer->typeCompilationUnit() == cu; + outer = outer->parent()) { + if (auto property = searchContextProperties( + v4, outer, name, hasProperty, base, + nullptr, originalLookup, ep)) { + return *property; + } + } + } + } // Search scope object if (scopeObject) { bool hasProp = false; - QQmlPropertyData *propertyData = nullptr; - QV4::ScopedValue result(scope, QV4::QObjectWrapper::getQmlProperty(v4, context, scopeObject, - name, QV4::QObjectWrapper::CheckRevision, &hasProp, &propertyData)); + const QQmlPropertyData *propertyData = nullptr; + + QV4::ScopedObject wrapper(scope, QV4::QObjectWrapper::wrap(v4, scopeObject)); + QV4::ScopedValue result(scope, QV4::QObjectWrapper::getQmlProperty( + v4, context, wrapper->d(), scopeObject, name, + getQmlPropertyFlags(lookup), &hasProp, &propertyData)); if (hasProp) { if (hasProperty) *hasProperty = true; if (base) - *base = QV4::QObjectWrapper::wrap(v4, scopeObject); + *base = wrapper; if (lookup && propertyData) { QQmlData *ddata = QQmlData::get(scopeObject, false); if (ddata && ddata->propertyCache) { - ScopedValue val(scope, base ? *base : Value::fromReturnedValue(QV4::QObjectWrapper::wrap(v4, scopeObject))); - const QObjectWrapper *That = static_cast<const QObjectWrapper *>(val->objectValue()); - lookup->qobjectLookup.ic = That->internalClass(); - lookup->qobjectLookup.propertyCache = ddata->propertyCache; - lookup->qobjectLookup.propertyCache->addref(); - lookup->qobjectLookup.propertyData = propertyData; - lookup->qmlContextPropertyGetter = QQmlContextWrapper::lookupScopeObjectProperty; + ScopedValue val( + scope, + base ? *base : Value::fromReturnedValue( + QV4::QObjectWrapper::wrap(v4, scopeObject))); + if (QObjectMethod *method = result->as<QObjectMethod>()) { + QV4::setupQObjectMethodLookup( + lookup, ddata, propertyData, val->objectValue(), + method->d()); + lookup->qmlContextPropertyGetter + = QQmlContextWrapper::lookupScopeObjectMethod; + } else { + QV4::setupQObjectLookup( + lookup, ddata, propertyData, val->objectValue()); + lookup->qmlContextPropertyGetter + = QQmlContextWrapper::lookupScopeObjectProperty; + } } } @@ -325,28 +345,39 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r // Search context object if (QObject *contextObject = context->contextObject()) { bool hasProp = false; - QQmlPropertyData *propertyData = nullptr; - result = QV4::QObjectWrapper::getQmlProperty(v4, context, contextObject, - name, QV4::QObjectWrapper::CheckRevision, - &hasProp, &propertyData); + const QQmlPropertyData *propertyData = nullptr; + QV4::ScopedObject wrapper(scope, QV4::QObjectWrapper::wrap(v4, contextObject)); + result = QV4::QObjectWrapper::getQmlProperty( + v4, context, wrapper->d(), contextObject, name, getQmlPropertyFlags(lookup), + &hasProp, &propertyData); if (hasProp) { if (hasProperty) *hasProperty = true; if (base) - *base = QV4::QObjectWrapper::wrap(v4, contextObject); + *base = wrapper; if (propertyData) { if (lookup) { QQmlData *ddata = QQmlData::get(contextObject, false); - if (ddata && ddata->propertyCache) { - ScopedValue val(scope, base ? *base - : Value::fromReturnedValue(QV4::QObjectWrapper::wrap(v4, contextObject))); - const QObjectWrapper *That = static_cast<const QObjectWrapper *>(val->objectValue()); - lookup->qobjectLookup.ic = That->internalClass(); - lookup->qobjectLookup.propertyCache = ddata->propertyCache; - lookup->qobjectLookup.propertyCache->addref(); - lookup->qobjectLookup.propertyData = propertyData; - lookup->qmlContextPropertyGetter = contextGetterFunction; + if (ddata && ddata->propertyCache + && lookup->qmlContextPropertyGetter != contextGetterFunction) { + ScopedValue val( + scope, + base ? *base : Value::fromReturnedValue( + QV4::QObjectWrapper::wrap(v4, contextObject))); + if (QObjectMethod *method = result->as<QObjectMethod>()) { + setupQObjectMethodLookup( + lookup, ddata, propertyData, val->objectValue(), + method->d()); + if (contextGetterFunction == lookupScopeObjectProperty) + lookup->qmlContextPropertyGetter = lookupScopeObjectMethod; + else + lookup->qmlContextPropertyGetter = lookupContextObjectMethod; + } else { + setupQObjectLookup( + lookup, ddata, propertyData, val->objectValue()); + lookup->qmlContextPropertyGetter = contextGetterFunction; + } } } else if (originalLookup) { originalLookup->qmlContextPropertyGetter = lookupInParentContextHierarchy; @@ -364,6 +395,11 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r lookup = nullptr; } + // Do the generic JS lookup late in case of a non-JavaScript context. + // The scope, context, types etc should be able to override it. + if (!isJSContext && performLookup(&result, hasProperty, jsLookup)) + return result->asReturnedValue(); + // Do a lookup in the global object here to avoid expressionContext->unresolvedNames becoming // true if we access properties of the global object. if (originalLookup) { @@ -381,7 +417,7 @@ ReturnedValue QQmlContextWrapper::getPropertyAndBase(const QQmlContextWrapper *r } lookup->qmlContextPropertyGetter = QQmlContextWrapper::resolveQmlContextPropertyLookupGetter; } else { - if (performGobalLookUp()) + if (performLookup(&result, hasProperty, globalLookup)) return result->asReturnedValue(); } @@ -429,17 +465,13 @@ bool QQmlContextWrapper::virtualPut(Managed *m, PropertyKey id, const Value &val ScopedString name(scope, id.asStringOrSymbol()); while (context) { - const QV4::IdentifierHash &properties = context->propertyNames(); // Search context properties - if (properties.count()) { - const int propertyIndex = properties.value(name); - if (propertyIndex != -1) { - if (propertyIndex < context->numIdValues()) { - v4->throwError(QLatin1String("left-hand side of assignment operator is not an lvalue")); - return false; - } + if (const int propertyIndex = context->propertyIndex(name); propertyIndex != -1) { + if (propertyIndex < context->numIdValues()) { + v4->throwError(QLatin1String("left-hand side of assignment operator is not an lvalue")); return false; } + return false; } // Search scope object @@ -469,8 +501,8 @@ ReturnedValue QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(Lookup * { Scope scope(engine); auto *func = engine->currentStackFrame->v4Function; - PropertyKey name =engine->identifierTable->asPropertyKey( - func->compilationUnit->runtimeStrings[l->nameIndex]); + ScopedPropertyKey name(scope, engine->identifierTable->asPropertyKey( + func->compilationUnit->runtimeStrings[l->nameIndex])); // Special hack for bounded signal expressions, where the parameters of signals are injected // into the handler expression through the locals of the call context. So for onClicked: { ... } @@ -484,7 +516,7 @@ ReturnedValue QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(Lookup * const auto location = func->sourceLocation(); qCWarning(lcQmlContext).nospace().noquote() << location.sourceFile << ":" << location.line << ":" << location.column - << " Parameter \"" << name.toQString() << "\" is not declared." + << " Parameter \"" << name->toQString() << "\" is not declared." << " Injection of parameters into signal handlers is deprecated." << " Use JavaScript functions with formal parameters instead."; @@ -508,8 +540,8 @@ ReturnedValue QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(Lookup * Scoped<QmlContext> callingQmlContext(scope, engine->qmlContext()); if (callingQmlContext) { Scoped<QQmlContextWrapper> qmlContextWrapper(scope, callingQmlContext->d()->qml()); - result = QQmlContextWrapper::getPropertyAndBase(qmlContextWrapper, name, /*receiver*/nullptr, &hasProperty, - base, l); + result = QQmlContextWrapper::getPropertyAndBase( + qmlContextWrapper, name, /*receiver*/nullptr, &hasProperty, base, l); } else { // Code path typical to worker scripts, compiled with lookups but no qml context. result = l->resolveGlobalGetter(engine); @@ -520,7 +552,7 @@ ReturnedValue QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(Lookup * } } if (!hasProperty) - return engine->throwReferenceError(name.toQString()); + return engine->throwReferenceError(name->toQString()); return result->asReturnedValue(); } @@ -547,9 +579,15 @@ ReturnedValue QQmlContextWrapper::lookupSingleton(Lookup *l, ExecutionEngine *en Q_UNUSED(engine); Q_UNUSED(base); - if (l->qmlContextSingletonLookup.singletonObject != nullptr) - return l->qmlContextSingletonLookup.singletonObject->asReturnedValue(); + return l->qmlContextSingletonLookup.singletonObject->asReturnedValue(); +} + +ReturnedValue QQmlContextWrapper::lookupValueSingleton(Lookup *l, ExecutionEngine *engine, Value *base) +{ + Q_UNUSED(engine); + Q_UNUSED(base); + Q_ASSERT(l->qmlContextSingletonLookup.singletonObject == nullptr); return l->qmlContextSingletonLookup.singletonValue; } @@ -574,7 +612,30 @@ ReturnedValue QQmlContextWrapper::lookupIdObject(Lookup *l, ExecutionEngine *eng return QV4::QObjectWrapper::wrap(engine, context->idValue(objectId)); } -ReturnedValue QQmlContextWrapper::lookupScopeObjectProperty(Lookup *l, ExecutionEngine *engine, Value *base) +ReturnedValue QQmlContextWrapper::lookupIdObjectInParentContext( + Lookup *l, ExecutionEngine *engine, Value *base) +{ + return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base); +} + +static ReturnedValue revertObjectPropertyLookup(Lookup *l, ExecutionEngine *engine, Value *base) +{ + l->qobjectLookup.propertyCache->release(); + l->qobjectLookup.propertyCache = nullptr; + l->qmlContextPropertyGetter = QQmlContextWrapper::resolveQmlContextPropertyLookupGetter; + return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base); +} + +static ReturnedValue revertObjectMethodLookup(Lookup *l, ExecutionEngine *engine, Value *base) +{ + l->qobjectMethodLookup.propertyCache->release(); + l->qobjectMethodLookup.propertyCache = nullptr; + l->qmlContextPropertyGetter = QQmlContextWrapper::resolveQmlContextPropertyLookupGetter; + return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base); +} + +template<typename Call> +ReturnedValue callWithScopeObject(ExecutionEngine *engine, Value *base, Call c) { Scope scope(engine); Scoped<QmlContext> qmlContext(scope, engine->qmlContext()); @@ -588,22 +649,40 @@ ReturnedValue QQmlContextWrapper::lookupScopeObjectProperty(Lookup *l, Execution if (QQmlData::wasDeleted(scopeObject)) return QV4::Encode::undefined(); - const auto revertLookup = [l, engine, base]() { - l->qobjectLookup.propertyCache->release(); - l->qobjectLookup.propertyCache = nullptr; - l->qmlContextPropertyGetter = QQmlContextWrapper::resolveQmlContextPropertyLookupGetter; - return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base); - }; - ScopedValue obj(scope, QV4::QObjectWrapper::wrap(engine, scopeObject)); if (base) *base = obj; - return QObjectWrapper::lookupGetterImpl(l, engine, obj, /*useOriginalProperty*/ true, revertLookup); + return c(obj); +} + +ReturnedValue QQmlContextWrapper::lookupScopeObjectProperty(Lookup *l, ExecutionEngine *engine, Value *base) +{ + return callWithScopeObject(engine, base, [l, engine, base](const Value &obj) { + const QObjectWrapper::Flags flags = l->forCall + ? QObjectWrapper::NoFlag + : QObjectWrapper::AttachMethods; + return QObjectWrapper::lookupPropertyGetterImpl(l, engine, obj, flags, [l, engine, base]() { + return revertObjectPropertyLookup(l, engine, base); + }); + }); +} + +ReturnedValue QQmlContextWrapper::lookupScopeObjectMethod(Lookup *l, ExecutionEngine *engine, Value *base) +{ + return callWithScopeObject(engine, base, [l, engine, base](const Value &obj) { + const QObjectWrapper::Flags flags = l->forCall + ? QObjectWrapper::NoFlag + : QObjectWrapper::AttachMethods; + return QObjectWrapper::lookupMethodGetterImpl(l, engine, obj, flags, [l, engine, base]() { + return revertObjectMethodLookup(l, engine, base); + }); + }); } -ReturnedValue QQmlContextWrapper::lookupContextObjectProperty(Lookup *l, ExecutionEngine *engine, Value *base) +template<typename Call> +ReturnedValue callWithContextObject(ExecutionEngine *engine, Value *base, Call c) { Scope scope(engine); Scoped<QmlContext> qmlContext(scope, engine->qmlContext()); @@ -621,19 +700,43 @@ ReturnedValue QQmlContextWrapper::lookupContextObjectProperty(Lookup *l, Executi if (QQmlData::wasDeleted(contextObject)) return QV4::Encode::undefined(); - const auto revertLookup = [l, engine, base]() { - l->qobjectLookup.propertyCache->release(); - l->qobjectLookup.propertyCache = nullptr; - l->qmlContextPropertyGetter = QQmlContextWrapper::resolveQmlContextPropertyLookupGetter; - return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base); - }; - ScopedValue obj(scope, QV4::QObjectWrapper::wrap(engine, contextObject)); if (base) *base = obj; - return QObjectWrapper::lookupGetterImpl(l, engine, obj, /*useOriginalProperty*/ true, revertLookup); + return c(obj); +} + +ReturnedValue QQmlContextWrapper::lookupContextObjectProperty( + Lookup *l, ExecutionEngine *engine, Value *base) +{ + return callWithContextObject(engine, base, [l, engine, base](const Value &obj) { + const QObjectWrapper::Flags flags = l->forCall + ? QObjectWrapper::NoFlag + : QObjectWrapper::AttachMethods; + return QObjectWrapper::lookupPropertyGetterImpl(l, engine, obj, flags, [l, engine, base]() { + return revertObjectPropertyLookup(l, engine, base); + }); + }); +} + +ReturnedValue QQmlContextWrapper::lookupContextObjectMethod( + Lookup *l, ExecutionEngine *engine, Value *base) +{ + return callWithContextObject(engine, base, [l, engine, base](const Value &obj) { + const QObjectWrapper::Flags flags = l->forCall + ? QObjectWrapper::NoFlag + : QObjectWrapper::AttachMethods; + return QObjectWrapper::lookupMethodGetterImpl(l, engine, obj, flags, [l, engine, base]() { + return revertObjectMethodLookup(l, engine, base); + }); + }); +} + +ReturnedValue QQmlContextWrapper::lookupScopeFallbackProperty(Lookup *l, ExecutionEngine *engine, Value *base) +{ + return resolveQmlContextPropertyLookupGetter(l, engine, base); } ReturnedValue QQmlContextWrapper::lookupInGlobalObject(Lookup *l, ExecutionEngine *engine, Value *base) @@ -676,12 +779,13 @@ ReturnedValue QQmlContextWrapper::lookupInParentContextHierarchy(Lookup *l, Exec // Search context object if (QObject *contextObject = context->contextObject()) { bool hasProp = false; + QV4::ScopedObject wrapper(scope, QV4::QObjectWrapper::wrap(engine, contextObject)); result = QV4::QObjectWrapper::getQmlProperty( - engine, context, contextObject, name, - QV4::QObjectWrapper::CheckRevision, &hasProp); + engine, context, wrapper->d(), contextObject, name, getQmlPropertyFlags(l), + &hasProp); if (hasProp) { if (base) - *base = QV4::QObjectWrapper::wrap(engine, contextObject); + *base = wrapper; return result->asReturnedValue(); } @@ -709,9 +813,9 @@ ReturnedValue QQmlContextWrapper::lookupType(Lookup *l, ExecutionEngine *engine, if (scopeObject && QQmlData::wasDeleted(scopeObject)) return QV4::Encode::undefined(); - Heap::Object *heapObject = l->qmlTypeLookup.qmlTypeWrapper; + Heap::Base *heapObject = l->qmlTypeLookup.qmlTypeWrapper; if (static_cast<Heap::QQmlTypeWrapper *>(heapObject)->object != scopeObject) { - l->qmlTypeLookup.qmlTypeWrapper = nullptr; + l->qmlTypeLookup.qmlTypeWrapper.clear(); l->qmlContextPropertyGetter = QQmlContextWrapper::resolveQmlContextPropertyLookupGetter; return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base); } |