Revision control
++ // 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
++
++ #include "qv4qmlcontext_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/qv4function_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>
++
++ QT_BEGIN_NAMESPACE
++
++ Q_STATIC_LOGGING_CATEGORY(lcQmlContext, "qt.qml.context");
++
++ using namespace QV4;
++
++ DEFINE_OBJECT_VTABLE(QQmlContextWrapper);
++ DEFINE_MANAGED_VTABLE(QmlContext);
++
++ void Heap::QQmlContextWrapper::init(QQmlRefPointer<QQmlContextData> context, QObject *scopeObject)
++ {
++ Object::init();
++ this->context = context.take();
++ this->scopeObject.init(scopeObject);
++ }
++
++ void Heap::QQmlContextWrapper::destroy()
++ {
++ context->release();
++ context = nullptr;
++ scopeObject.destroy();
++ Object::destroy();
++ }
++
++ static OptionalReturnedValue searchContextProperties(
++ QV4::ExecutionEngine *v4, const QQmlRefPointer<QQmlContextData> &context, String *name,
++ bool *hasProperty, Value *base, QV4::Lookup *lookup, QV4::Lookup *originalLookup,
++ QQmlEnginePrivate *ep)
++ {
++ const int propertyIdx = context->propertyIndex(name->d());
++
++ if (propertyIdx == -1)
++ return OptionalReturnedValue();
++
++ if (propertyIdx < context->numIdValues()) {
++ if (hasProperty)
++ *hasProperty = true;
++
++ if (lookup) {
++ lookup->qmlContextIdObjectLookup.objectId = propertyIdx;
++ lookup->call = Lookup::Call::ContextGetterIdObject;
++ return OptionalReturnedValue(lookup->contextGetter(v4, base));
++ } else if (originalLookup) {
++ originalLookup->call = Lookup::Call::ContextGetterInParentContextHierarchy;
++ }
++
++ if (ep->propertyCapture)
++ ep->propertyCapture->captureProperty(context->idValueBindings(propertyIdx));
++ return OptionalReturnedValue(QV4::QObjectWrapper::wrap(v4, context->idValue(propertyIdx)));
++ }
++
++ QQmlContextPrivate *cp = context->asQQmlContextPrivate();
++
++ if (ep->propertyCapture)
++ ep->propertyCapture->captureProperty(context->asQQmlContext(), -1, propertyIdx + cp->notifyIndex());
++
++ const QVariant &value = cp->propertyValue(propertyIdx);
++ if (hasProperty)
++ *hasProperty = true;
++ if (value.userType() == qMetaTypeId<QList<QObject*> >()) {
++ QQmlListProperty<QObject> prop(context->asQQmlContext(), (void*) qintptr(propertyIdx),
++ QQmlContextPrivate::context_count,
++ QQmlContextPrivate::context_at);
++ 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())
++ return Object::virtualGet(resource, id, receiver, hasProperty);
++
++ QV4::ExecutionEngine *v4 = resource->engine();
++ QV4::Scope scope(v4);
++
++ if (v4->callingQmlContext().data() != resource->d()->context) {
++ if (resource->d()->module) {
++ Scoped<Module> module(scope, resource->d()->module);
++ bool hasProp = false;
++ ScopedValue value(scope, module->get(id, receiver, &hasProp));
++ if (hasProp) {
++ if (hasProperty)
++ *hasProperty = hasProp;
++ return value->asReturnedValue();
++ }
++ }
++
++ return Object::virtualGet(resource, id, receiver, hasProperty);
++ }
++
++ 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.
++ QQmlRefPointer<QQmlContextData> context = resource->getContext();
++ QQmlRefPointer<QQmlContextData> expressionContext = context;
++
++ if (!context) {
++ if (hasProperty)
++ *hasProperty = true;
++ return result->asReturnedValue();
++ }
++
++ // Search type (attached property/enum/imported scripts) names
++ // while (context) {
++ // Search context properties
++ // Search scope object
++ // Search context object
++ // context = context->parent
++ // }
++
++ QObject *scopeObject = resource->getScopeObject();
++
++ ScopedString name(scope, id.asStringOrSymbol());
++
++ 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:
++ //
++ // (1) The implicit creation of properties is necessary because it will also result in
++ // a recorded capture, which will allow a re-evaluation of bindings when the value
++ // is populated later. See QTBUG-35233 and the test-case in tst_qqmlpropertymap.
++ //
++ // (1) Looking up "console" in order to place a console.log() call for example must
++ // find the console instead of creating a new property. Therefore we prioritize the
++ // lookup in the global object here.
++ //
++ // 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.
++ 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 (performLookup(&result, hasProperty, globalLookup))
++ return result->asReturnedValue();
++ }
++
++ 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<QQmlImport::AllowRecursion>(
++ name, v4->typeLoader());
++
++ if (r.isValid()) {
++ if (hasProperty)
++ *hasProperty = true;
++ if (r.scriptIndex != -1) {
++ if (lookup) {
++ lookup->qmlContextScriptLookup.scriptIndex = r.scriptIndex;
++ lookup->call = Lookup::Call::ContextGetterScript;
++ return lookup->contextGetter(v4, base);
++ }
++ QV4::ScopedObject scripts(scope, context->importedScripts());
++ if (scripts)
++ return scripts->get(r.scriptIndex);
++ 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.set(v4,
++ Value::fromReturnedValue(
++ QQmlTypeWrapper::create(v4, nullptr, r.type)
++ ).heapObject());
++ } else {
++ QJSValue singleton = e->singletonInstance<QJSValue>(r.type);
++
++ // QString values should already have been put on the engine heap at
++ // this point to manage their memory. We later assume this has already
++ // happened.
++ Q_ASSERT(!QJSValuePrivate::asQString(&singleton));
++
++ if (QV4::Value *val = QJSValuePrivate::takeManagedValue(&singleton)) {
++ lookup->qmlContextSingletonLookup.singletonObject.set(v4, val->heapObject());
++ } else {
++ lookup->qmlContextSingletonLookup.singletonValue = QJSValuePrivate::asReturnedValue(&singleton);
++ isValueSingleton = true;
++ }
++ }
++ lookup->call = isValueSingleton
++ ? Lookup::Call::ContextGetterValueSingleton
++ : Lookup::Call::ContextGetterSingleton;
++ return lookup->contextGetter(v4, base);
++ }
++ }
++ result = QQmlTypeWrapper::create(v4, scopeObject, r.type);
++ } else if (r.importNamespace) {
++ result = QQmlTypeWrapper::create(v4, scopeObject, context->imports(), r.importNamespace);
++ }
++ if (lookup) {
++ lookup->qmlTypeLookup.qmlTypeWrapper.set(v4, result->heapObject());
++ lookup->call = Lookup::Call::ContextGetterType;
++ }
++ return result->asReturnedValue();
++ }
++
++ // Fall through
++ }
++
++ Lookup * const originalLookup = lookup;
++
++ Lookup::Call contextGetterCall = Lookup::Call::ContextGetterContextObjectProperty;
++
++ // minor optimization so we don't potentially try two property lookups on the same object
++ if (scopeObject == context->contextObject()) {
++ scopeObject = nullptr;
++ contextGetterCall = Lookup::Call::ContextGetterScopeObjectProperty;
++ }
++
++ QQmlRefPointer<QQmlContextData> outer = context;
++ while (context) {
++ 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;
++
++ 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 = wrapper;
++
++ if (lookup) {
++ QQmlData *ddata = QQmlData::get(scopeObject, false);
++ if (ddata && ddata->propertyCache) {
++ ScopedValue val(
++ scope,
++ base ? *base : Value::fromReturnedValue(
++ QV4::QObjectWrapper::wrap(v4, scopeObject)));
++ if (QObjectMethod *method = result->as<QObjectMethod>()) {
++ QV4::setupQObjectMethodLookup(
++ lookup, ddata->propertyCache, propertyData,
++ val->objectValue(), method->d());
++ lookup->call = Lookup::Call::ContextGetterScopeObjectMethod;
++ } else {
++ QV4::setupQObjectLookup(
++ lookup, ddata, propertyData, val->objectValue());
++ lookup->call = Lookup::Call::ContextGetterScopeObjectProperty;
++ }
++ }
++ }
++
++ return result->asReturnedValue();
++ }
++ }
++ scopeObject = nullptr;
++
++
++ // Search context object
++ if (QObject *contextObject = context->contextObject()) {
++ bool hasProp = false;
++ 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 = wrapper;
++
++ if (lookup) {
++ QQmlData *ddata = QQmlData::get(contextObject, false);
++ if (ddata && ddata->propertyCache && lookup->call != contextGetterCall) {
++ ScopedValue val(
++ scope,
++ base ? *base : Value::fromReturnedValue(
++ QV4::QObjectWrapper::wrap(v4, contextObject)));
++ if (QObjectMethod *method = result->as<QObjectMethod>()) {
++ setupQObjectMethodLookup(
++ lookup, ddata->propertyCache, propertyData,
++ val->objectValue(), method->d());
++ if (contextGetterCall == Lookup::Call::ContextGetterScopeObjectProperty)
++ lookup->call = Lookup::Call::ContextGetterScopeObjectMethod;
++ else
++ lookup->call = Lookup::Call::ContextGetterContextObjectMethod;
++ } else {
++ setupQObjectLookup(
++ lookup, ddata, propertyData, val->objectValue());
++ lookup->call = contextGetterCall;
++ }
++ }
++ } else if (originalLookup) {
++ originalLookup->call = Lookup::Call::ContextGetterInParentContextHierarchy;
++ }
++
++ return result->asReturnedValue();
++ }
++ }
++
++ context = context->parent();
++
++ // As the hierarchy of contexts is not stable, we can't do accelerated lookups beyond
++ // the immediate QML context (of the .qml file).
++ 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) {
++ // Try a lookup in the global object. It's theoretically possible to first find a property
++ // in the global object and then later a context property with the same name is added, but that
++ // never really worked as we used to detect access to global properties at type compile time anyway.
++ lookup = originalLookup;
++ result = lookup->resolveGlobalGetter(v4);
++ if (lookup->call != Lookup::Call::GlobalGetterGeneric) {
++ if (hasProperty)
++ *hasProperty = true;
++ lookup->qmlContextGlobalLookup.getterTrampoline = lookup->call;
++ lookup->call = Lookup::Call::ContextGetterInGlobalObject;
++ return result->asReturnedValue();
++ }
++ lookup->call = Lookup::Call::ContextGetterGeneric;
++ } else {
++ if (performLookup(&result, hasProperty, globalLookup))
++ return result->asReturnedValue();
++ }
++
++ expressionContext->setUnresolvedNames(true);
++
++ return Encode::undefined();
++ }
++
++ ReturnedValue QQmlContextWrapper::virtualGet(const Managed *m, PropertyKey id, const Value *receiver, bool *hasProperty)
++ {
++ Q_ASSERT(m->as<QQmlContextWrapper>());
++ const QQmlContextWrapper *This = static_cast<const QQmlContextWrapper *>(m);
++ return getPropertyAndBase(This, id, receiver, hasProperty, /*base*/nullptr);
++ }
++
++ bool QQmlContextWrapper::virtualPut(Managed *m, PropertyKey id, const Value &value, Value *receiver)
++ {
++ Q_ASSERT(m->as<QQmlContextWrapper>());
++
++ if (id.isSymbol() || id.isArrayIndex())
++ return Object::virtualPut(m, id, value, receiver);
++
++ QQmlContextWrapper *resource = static_cast<QQmlContextWrapper *>(m);
++ ExecutionEngine *v4 = resource->engine();
++ QV4::Scope scope(v4);
++ if (scope.hasException())
++ return false;
++ QV4::Scoped<QQmlContextWrapper> wrapper(scope, resource);
++
++ auto member = wrapper->internalClass()->findValueOrSetter(id);
++ if (member.index < UINT_MAX)
++ return wrapper->putValue(member.index, member.attrs, value);
++
++ // It's possible we could delay the calculation of the "actual" context (in the case
++ // of sub contexts) until it is definitely needed.
++ QQmlRefPointer<QQmlContextData> context = wrapper->getContext();
++ QQmlRefPointer<QQmlContextData> expressionContext = context;
++
++ if (!context)
++ return false;
++
++ // See QQmlContextWrapper::Getter for resolution order
++
++ QObject *scopeObject = wrapper->getScopeObject();
++ ScopedString name(scope, id.asStringOrSymbol());
++
++ while (context) {
++ // Search context properties
++ if (const int propertyIndex = context->propertyIndex(name->d()); 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
++ if (scopeObject &&
++ QV4::QObjectWrapper::setQmlProperty(v4, context, scopeObject, name, QV4::QObjectWrapper::CheckRevision, value))
++ return true;
++ scopeObject = nullptr;
++
++ // Search context object
++ if (context->contextObject() &&
++ QV4::QObjectWrapper::setQmlProperty(v4, context, context->contextObject(), name,
++ QV4::QObjectWrapper::CheckRevision, value))
++ return true;
++
++ context = context->parent();
++ }
++
++ expressionContext->setUnresolvedNames(true);
++
++ QString error = QLatin1String("Invalid write to global property \"") + name->toQString() +
++ QLatin1Char('"');
++ v4->throwError(error);
++ return false;
++ }
++
++ ReturnedValue QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ Scope scope(engine);
++ auto *func = engine->currentStackFrame->v4Function;
++ 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: { ... }
++ // the parameters of the clicked signal are injected and we must allow for them to be found here
++ // before any other property from the QML context.
++ for (Heap::ExecutionContext *ctx = engine->currentContext()->d(); ctx; ctx = ctx->outer) {
++ if (ctx->type == Heap::ExecutionContext::Type_CallContext) {
++ const uint index = ctx->internalClass->indexOfValueOrGetter(name);
++ if (index < std::numeric_limits<uint>::max()) {
++ if (!func->detectedInjectedParameters) {
++ const auto location = func->sourceLocation();
++ qCWarning(lcQmlContext).nospace().noquote()
++ << location.sourceFile << ":" << location.line << ":" << location.column
++ << " Parameter \"" << name->toQString() << "\" is not declared."
++ << " Injection of parameters into signal handlers is deprecated."
++ << " Use JavaScript functions with formal parameters instead.";
++
++ // Don't warn over and over for the same function
++ func->detectedInjectedParameters = true;
++ }
++
++ return static_cast<Heap::CallContext *>(ctx)->locals[index].asReturnedValue();
++ }
++ }
++
++ // Skip only block and call contexts.
++ // Other contexts need a regular QML property lookup. See below.
++ if (ctx->type != Heap::ExecutionContext::Type_BlockContext && ctx->type != Heap::ExecutionContext::Type_CallContext)
++ break;
++ }
++
++ bool hasProperty = false;
++ ScopedValue result(scope);
++
++ 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);
++ } else {
++ // Code path typical to worker scripts, compiled with lookups but no qml context.
++ result = l->resolveGlobalGetter(engine);
++ if (l->call != Lookup::Call::GlobalGetterGeneric) {
++ hasProperty = true;
++ l->qmlContextGlobalLookup.getterTrampoline = l->call;
++ l->call = Lookup::Call::ContextGetterInGlobalObject;
++ }
++ }
++ if (!hasProperty)
++ return engine->throwReferenceError(name->toQString());
++ return result->asReturnedValue();
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupScript(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ Q_UNUSED(base);
++ Scope scope(engine);
++ Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
++ if (!qmlContext)
++ return QV4::Encode::null();
++
++ QQmlRefPointer<QQmlContextData> context = qmlContext->qmlContext();
++ if (!context)
++ return QV4::Encode::null();
++
++ QV4::ScopedObject scripts(scope, context->importedScripts());
++ if (!scripts)
++ return QV4::Encode::null();
++ return scripts->get(l->qmlContextScriptLookup.scriptIndex);
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupSingleton(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ Q_UNUSED(engine);
++ Q_UNUSED(base);
++
++ 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;
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupIdObject(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ Q_UNUSED(base);
++ Scope scope(engine);
++ Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
++ if (!qmlContext)
++ return QV4::Encode::null();
++
++ QQmlRefPointer<QQmlContextData> context = qmlContext->qmlContext();
++ if (!context)
++ return QV4::Encode::null();
++
++ QQmlEnginePrivate *qmlEngine = QQmlEnginePrivate::get(engine->qmlEngine());
++ const int objectId = l->qmlContextIdObjectLookup.objectId;
++
++ if (qmlEngine->propertyCapture)
++ qmlEngine->propertyCapture->captureProperty(context->idValueBindings(objectId));
++
++ return QV4::QObjectWrapper::wrap(engine, context->idValue(objectId));
++ }
++
++ 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->call = Lookup::Call::ContextGetterGeneric;
++ return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base);
++ }
++
++ static ReturnedValue revertObjectMethodLookup(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ l->qobjectMethodLookup.propertyCache->release();
++ l->qobjectMethodLookup.propertyCache = nullptr;
++ l->call = Lookup::Call::ContextGetterGeneric;
++ return QQmlContextWrapper::resolveQmlContextPropertyLookupGetter(l, engine, base);
++ }
++
++ // The object may be gone once it is being destroyed. Its name is not defined then, just like
++ // when resolving the name anew.
++ static ReturnedValue throwLostObjectReferenceError(Lookup *l, ExecutionEngine *engine)
++ {
++ return engine->throwReferenceError(
++ engine->currentStackFrame->v4Function->compilationUnit->runtimeStrings[l->nameIndex]
++ ->toQString());
++ }
++
++ template<typename Call>
++ ReturnedValue callWithScopeObject(Lookup *l, ExecutionEngine *engine, Value *base, Call c)
++ {
++ Scope scope(engine);
++ Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
++ if (!qmlContext)
++ return QV4::Encode::undefined();
++
++ QObject *scopeObject = qmlContext->qmlScope();
++ if (!scopeObject || QQmlData::wasDeleted(scopeObject))
++ return throwLostObjectReferenceError(l, engine);
++
++ ScopedValue obj(scope, QV4::QObjectWrapper::wrap(engine, scopeObject));
++
++ if (base)
++ *base = obj;
++
++ return c(obj);
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupScopeObjectProperty(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ return callWithScopeObject(l, 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(l, 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);
++ });
++ });
++ }
++
++ template<typename Call>
++ ReturnedValue callWithContextObject(Lookup *l, ExecutionEngine *engine, Value *base, Call c)
++ {
++ Scope scope(engine);
++ Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
++ if (!qmlContext)
++ return QV4::Encode::undefined();
++
++ QQmlRefPointer<QQmlContextData> context = qmlContext->qmlContext();
++ if (!context)
++ return QV4::Encode::undefined();
++
++ QObject *contextObject = context->contextObject();
++ if (!contextObject || QQmlData::wasDeleted(contextObject))
++ return throwLostObjectReferenceError(l, engine);
++
++ ScopedValue obj(scope, QV4::QObjectWrapper::wrap(engine, contextObject));
++
++ if (base)
++ *base = obj;
++
++ return c(obj);
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupContextObjectProperty(
++ Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ return callWithContextObject(l, 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(l, 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)
++ {
++ Q_UNUSED(base);
++ ReturnedValue result = Lookup::doCallGlobal(
++ l->qmlContextGlobalLookup.getterTrampoline, l, engine);
++ // In the unlikely event of mutation of the global object, update the trampoline.
++ if (l->call != Lookup::Call::ContextGetterInGlobalObject) {
++ l->qmlContextGlobalLookup.getterTrampoline = l->call;
++ l->call = Lookup::Call::ContextGetterInGlobalObject;
++ }
++ return result;
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupInParentContextHierarchy(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ Scope scope(engine);
++ Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
++ if (!qmlContext)
++ return QV4::Encode::undefined();
++
++ QQmlRefPointer<QQmlContextData> context = qmlContext->qmlContext();
++ if (!context)
++ return QV4::Encode::undefined();
++
++ QQmlRefPointer<QQmlContextData> expressionContext = context;
++
++ QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine->qmlEngine());
++
++ PropertyKey id =engine->identifierTable->asPropertyKey(engine->currentStackFrame->v4Function->compilationUnit->
++ runtimeStrings[l->nameIndex]);
++ ScopedString name(scope, id.asStringOrSymbol());
++
++ ScopedValue result(scope);
++
++ for (context = context->parent(); context; context = context->parent()) {
++ if (auto property = searchContextProperties(engine, context, name, nullptr, base, nullptr, nullptr, ep))
++ return *property;
++
++ // 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, wrapper->d(), contextObject, name, getQmlPropertyFlags(l),
++ &hasProp);
++ if (hasProp) {
++ if (base)
++ *base = wrapper;
++
++ return result->asReturnedValue();
++ }
++ }
++ }
++
++ bool hasProp = false;
++ result = engine->globalObject->get(name, &hasProp);
++ if (hasProp)
++ return result->asReturnedValue();
++
++ expressionContext->setUnresolvedNames(true);
++
++ return Encode::undefined();
++ }
++
++ ReturnedValue QQmlContextWrapper::lookupType(Lookup *l, ExecutionEngine *engine, Value *base)
++ {
++ Q_UNUSED(base)
++
++ Scope scope(engine);
++ Scoped<QmlContext> qmlContext(scope, engine->qmlContext());
++ if (!qmlContext)
++ return QV4::Encode::undefined();
++
++ QObject *currentScopeObject = qmlContext->qmlScope();
++ if (currentScopeObject && QQmlData::wasDeleted(currentScopeObject))
++ return QV4::Encode::undefined();
++
++ Heap::Base *heapObject = l->qmlTypeLookup.qmlTypeWrapper;
++ Heap::QQmlTypeWrapper *typeWrapper = static_cast<Heap::QQmlTypeWrapper *>(heapObject);
++ QObject *lookupScopeObject = typeWrapper->object;
++ if (lookupScopeObject == currentScopeObject)
++ return Value::fromHeapObject(heapObject).asReturnedValue();
++
++ // The type wrapper is still valid. We can simply rebase it onto the new scope.
++ // The type cannot have changed. The only thing that may have changed is the
++ // base object of any attachment.
++ Scoped<QQmlTypeWrapper> newWrapper(scope);
++ switch (typeWrapper->kind()) {
++ case Heap::QQmlTypeWrapper::Type:
++ newWrapper = QQmlTypeWrapper::create(engine, currentScopeObject, typeWrapper->type(),
++ typeWrapper->typeNameMode());
++ break;
++ case Heap::QQmlTypeWrapper::Namespace:
++ newWrapper = QQmlTypeWrapper::create(
++ engine, currentScopeObject, typeWrapper->n.typeNamespace,
++ typeWrapper->n.importNamespace, typeWrapper->typeNameMode());
++ break;
++ }
++ l->qmlTypeLookup.qmlTypeWrapper.set(engine, newWrapper->d());
++ return newWrapper.asReturnedValue();
++ }
++
++ void Heap::QmlContext::init(QV4::ExecutionContext *outerContext, QV4::QQmlContextWrapper *qml)
++ {
++ Heap::ExecutionContext::init(Heap::ExecutionContext::Type_QmlContext);
++ outer.set(internalClass->engine, outerContext->d());
++
++ this->activation.set(internalClass->engine, qml->d());
++ }
++
++ Heap::QmlContext *QmlContext::create(
++ ExecutionContext *parent, QQmlRefPointer<QQmlContextData> context,
++ QObject *scopeObject)
++ {
++ Scope scope(parent);
++
++ Scoped<QQmlContextWrapper> qml(
++ scope, scope.engine->memoryManager->allocate<QQmlContextWrapper>(
++ std::move(context), scopeObject));
++ Heap::QmlContext *c = scope.engine->memoryManager->alloc<QmlContext>(parent, qml);
++ Q_ASSERT(c->vtable() == staticVTable());
++ return c;
++ }
++
++ QT_END_NAMESPACE