Revision control
++ // Copyright (C) 2026 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 reason:default
++
++ #include "qqmlpreviewobjectpatch_p.h"
++
++ #include <private/qqmlcomponent_p.h>
++ #include <private/qqmlcontextdata_p.h>
++ #include <private/qqmldata_p.h>
++ #include <private/qqmljavascriptexpression_p.h>
++ #include <private/qqmlobjectcreator_p.h>
++ #include <private/qqmlpreviewbindingpatchcontext_p.h>
++ #include <private/qqmlpreviewdiff_p.h>
++ #include <private/qqmlpropertyresolver_p.h>
++ #include <private/qqmlscriptdata_p.h>
++ #include <private/qqmlsignalnames_p.h>
++ #include <private/qqmlvme_p.h>
++ #include <private/qqmlvmemetaobject_p.h>
++ #include <private/qv4functionobject_p.h>
++ #include <private/qv4generatorobject_p.h>
++ #include <private/qv4qmlcontext_p.h>
++ #include <private/qv4resolvedtypereference_p.h>
++
++ #include <QtQml/qqmlcomponent.h>
++ #include <QtQml/qqmlproperty.h>
++
++ #include <QtCore/qset.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QQmlPreview {
++
++ // The indices at which object appears in oldUnit: its own (ddata) index plus any indices it
++ // occupies through composite base levels (the VME meta-object chain).
++ static QVarLengthArray<int, 4>
++ objectIndices(QObject *object, const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit)
++ {
++ QVarLengthArray<int, 4> objectIndices;
++
++ QQmlData *ddata = QQmlData::get(object);
++ if (!ddata)
++ return objectIndices;
++
++ if (ddata->compilationUnit == oldUnit)
++ objectIndices.push_back(ddata->cuObjectIndex);
++ if (ddata->hasVMEMetaObject) {
++ for (QQmlVMEMetaObject *vme =
++ static_cast<QQmlVMEMetaObject *>(QObjectPrivate::get(object)->metaObject);
++ vme; vme = vme->parentVMEMetaObject()) {
++ if (vme->compilationUnit() == oldUnit)
++ objectIndices.push_back(vme->qmlObjectId());
++ }
++ }
++
++ return objectIndices;
++ }
++
++ static QQmlPropertyCache::ConstPtr
++ nonCompositeBaseType(const QQmlPropertyCache::ConstPtr &propertyCache)
++ {
++ for (QQmlPropertyCache::ConstPtr parent = propertyCache; parent; parent = parent->parent()) {
++ if (!parent->isComposite())
++ return parent;
++ }
++
++ return QQmlPropertyCache::ConstPtr();
++ }
++
++ static bool
++ hasChangedNonCompositeBaseType(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit,
++ int objectIndex)
++ {
++ const QV4::CompiledData::Object *oldObj = oldUnit->objectAt(objectIndex);
++ const auto *oldTypeRef = oldUnit->resolvedType(oldObj->inheritedTypeNameIndex);
++ if (!oldTypeRef)
++ return false; // Grouped property sub-objects have no inherited type.
++
++ const QV4::CompiledData::Object *newObj = newUnit->objectAt(objectIndex);
++ const auto *newTypeRef = newUnit->resolvedType(newObj->inheritedTypeNameIndex);
++ if (!newTypeRef)
++ return true; // Type disappeared — definitely changed.
++
++ return nonCompositeBaseType(oldTypeRef->typePropertyCache())
++ != nonCompositeBaseType(newTypeRef->typePropertyCache());
++ }
++
++ // Whether the object at objectIndex is the root of a component: The document, an inline component,
++ // or an explicit or implicit Component.
++ static bool isComponentRoot(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &unit,
++ int objectIndex)
++ {
++ if (objectIndex == 0)
++ return true;
++
++ if (objectIndex >= unit->objectCount())
++ return false;
++
++ if (unit->objectAt(objectIndex)->hasFlag(QV4::CompiledData::Object::IsInlineComponentRoot))
++ return true;
++
++ if (unit->baseCompilationUnit()->implicitComponentForObject(objectIndex) >= 0)
++ return true;
++
++ for (int i = 0, end = unit->objectCount(); i < end; ++i) {
++ const QV4::CompiledData::Object *object = unit->objectAt(i);
++ if (object->hasFlag(QV4::CompiledData::Object::IsComponent)
++ && int(object->bindingTable()->value.objectIndex) == objectIndex) {
++ return true;
++ }
++ }
++ return false;
++ }
++
++ // reset() + repopulateBindings() cannot faithfully reproduce some components in place,
++ // because either:
++ // - Its index doesn't denote a component root anymore in the new unit, because objects were
++ // added or removed in front of it.
++ // - Its non-composite (C++) base type changed: the reused QObject is still an instance of the old
++ // class (see hasChangedNonCompositeBaseType).
++ // - It carries deferred bindings. We cannot re-install those because their handling is in the
++ // type's discretion.
++ // Fore those return false here. Otherwise return true.
++ static bool
++ canRebuildComponentRootInPlace(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit,
++ int objectIndex)
++ {
++ // An index out of range in the new CU is obsolete: rebuildObject() skips it and applyDiff()
++ // retires it afterwards. There is nothing to recreate from an enclosing root.
++ if (objectIndex >= newUnit->objectCount())
++ return true;
++
++ if (!isComponentRoot(newUnit, objectIndex))
++ return false;
++
++ if (newUnit->objectHasDeferredBindings(objectIndex))
++ return false;
++
++ return !hasChangedNonCompositeBaseType(oldUnit, newUnit, objectIndex);
++ }
++
++ // Re-resolve the object's precomputed binding-target table against its relinked property cache.
++ static void refreshBindingPropertyData(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &cu,
++ int objectIndex, const QQmlPropertyCache::ConstPtr &cache)
++ {
++ QList<QV4::CompiledData::BindingPropertyData> &table =
++ cu->baseCompilationUnit()->bindingPropertyDataPerObject;
++ if (objectIndex >= table.size())
++ return;
++
++ QV4::CompiledData::BindingPropertyData &bindingData = table[objectIndex];
++
++ const QV4::CompiledData::Object *obj = cu->objectAt(objectIndex);
++ const QQmlPropertyResolver resolver(cache);
++
++ const QV4::CompiledData::Binding *binding = obj->bindingTable();
++ for (qsizetype i = 0, end = bindingData.size(); i < end; ++i, ++binding) {
++ if (!bindingData.at(i))
++ continue;
++
++ Q_ASSERT(i < obj->nBindings);
++ const QString name = BindingPatchContext::targetPropertyName(cu, objectIndex, binding);
++ if (name.isEmpty())
++ continue;
++
++ if (cu->bindingIsSignalHandlerExpression(objectIndex, i)
++ || cu->bindingIsSignalHandlerObject(objectIndex, i)) {
++ bindingData[i] = resolver.signal(
++ *QQmlSignalNames::anyHandlerNameToSignalName(name), nullptr,
++ QQmlPropertyResolver::IgnoreRevision);
++ } else if (cu->bindingIsPropertyObserver(objectIndex, i)) {
++ bindingData[i] = resolver.property(
++ *QQmlSignalNames::changedHandlerNameToPropertyName(name), nullptr,
++ QQmlPropertyResolver::IgnoreRevision);
++ } else {
++ bindingData[i] = resolver.property(
++ name, nullptr, QQmlPropertyResolver::IgnoreRevision);
++ }
++ }
++ }
++
++ // Ensure the property cache at objectIndex in cu is derived from actualParent, the cache we just
++ // used for the level below it in the VME chain.
++ static QQmlPropertyCache::ConstPtr
++ relinkCache(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &cu, int objectIndex,
++ const QQmlPropertyCache::ConstPtr &actualParent)
++ {
++ QQmlPropertyCacheVector *caches = cu->propertyCachesPtr();
++ QQmlPropertyCache::ConstPtr cache = caches->at(objectIndex);
++
++ // The bottom-most composite level's own base is a non-composite (C++) type. That base never
++ // changes across a reload since a changed non-composite base is rejected by
++ // hasChangedNonCompositeBaseType.
++ if (!actualParent)
++ return cache;
++
++ // A type that needs no VME meta-object of its own reuses its base type's property cache.
++ if (!caches->needsVMEMetaObject(objectIndex)) {
++ if (cache != actualParent) {
++ caches->set(objectIndex, actualParent);
++ refreshBindingPropertyData(cu, objectIndex, actualParent);
++ }
++ return actualParent;
++ }
++
++ // A type with its own cache derived from the base: re-derive it from the relinked base so its
++ // inherited offsets match the (possibly changed) base layout.
++ if (cache->parent() != actualParent) {
++ cache = cache->rebased(actualParent);
++ caches->set(objectIndex, cache);
++ refreshBindingPropertyData(cu, objectIndex, cache);
++ }
++
++ return cache;
++ }
++
++ // Re-link every property cache in cu that (transitively) derives oldBaseCache so it derives
++ // newBaseCache instead.
++ static void relinkDerivedCaches(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &cu,
++ const QQmlPropertyCache::ConstPtr &oldBaseCache,
++ const QQmlPropertyCache::ConstPtr &newBaseCache)
++ {
++ QQmlPropertyCacheVector *caches = cu->propertyCachesPtr();
++ Q_ASSERT(caches);
++
++ QHash<const QQmlPropertyCache *, QQmlPropertyCache::ConstPtr> replacements;
++ replacements.insert(oldBaseCache.data(), newBaseCache);
++
++ for (bool changed = true; changed;) {
++ changed = false;
++ for (int i = 0, end = caches->count(); i < end; ++i) {
++ const QQmlPropertyCache::ConstPtr cache = caches->at(i);
++ if (!cache)
++ continue;
++
++ const auto it = replacements.constFind(cache->parent().data());
++ if (it == replacements.constEnd())
++ continue;
++
++ const QQmlPropertyCache::ConstPtr rebased = cache->rebased(*it);
++ replacements.insert(cache.data(), rebased);
++ caches->set(i, rebased);
++ refreshBindingPropertyData(cu, i, rebased);
++ changed = true;
++ }
++ }
++ }
++
++ struct RebuildTarget
++ {
++ QObject *object = nullptr;
++ int index = -1;
++ QQmlRefPointer<QV4::ExecutableCompilationUnit> oldCu;
++ QQmlRefPointer<QV4::ExecutableCompilationUnit> newCu;
++ };
++
++ // Walk the type resolution chain starting from the object at cuIndex in unit,
++ // collecting all composite (QML-defined) base type levels. Returns them ordered
++ // deepest-first (e.g., grandparent before parent).
++ static std::vector<CompositeLevel>
++ collectCompositeLevels(const CompositeLevel &instanceLevel,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ std::vector<CompositeLevel> levels;
++
++ auto currentUnit = instanceLevel.newCu;
++ const QV4::CompiledData::Object *obj = currentUnit->objectAt(instanceLevel.objectIndex);
++ const QV4::ResolvedTypeReference *typeRef =
++ currentUnit->resolvedType(obj->inheritedTypeNameIndex);
++
++ while (typeRef && typeRef->type().isComposite()) {
++ QQmlRefPointer<QV4::ExecutableCompilationUnit> cu = typeRef->isSelfReference()
++ ? currentUnit
++ : currentUnit->engine->executableCompilationUnit(typeRef->compilationUnit());
++ Q_ASSERT(cu);
++
++ // Replace the old unit with the new one wherever it occurs
++ const auto oldCu = cu;
++ if (cu == oldUnit)
++ cu = newUnit;
++
++ int rootIndex;
++ QString icName;
++ if (typeRef->type().isInlineComponent()) {
++ icName = typeRef->type().elementName();
++ rootIndex = cu->inlineComponentId(icName);
++ } else {
++ rootIndex = 0;
++ }
++
++ levels.push_back({ oldCu, cu, rootIndex, icName, nullptr });
++
++ if (rootIndex < 0 || rootIndex >= cu->objectCount())
++ break;
++
++ // Walk deeper into the base type
++ const QV4::CompiledData::Object *rootObj = cu->objectAt(rootIndex);
++ typeRef = cu->resolvedType(rootObj->inheritedTypeNameIndex);
++ currentUnit = cu;
++ }
++
++ return levels;
++ }
++
++ // Rebuilding a component root replaces the contexts it is the context object of. Instances of
++ // inner components created in such a context still have it as parent context. When rebuilding
++ // those, we have to parent their new contexts to the replacements, or they keep resolving ids
++ // against the old context, whose objects have been retired.
++ struct ReplacedContext
++ {
++ QQmlRefPointer<QQmlContextData> oldContext;
++ QQmlRefPointer<QQmlContextData> newContext;
++ };
++ using ReplacedContexts = QHash<const QQmlContextData *, ReplacedContext>;
++
++ static QQmlRefPointer<QQmlContextData>
++ currentContext(const QQmlRefPointer<QQmlContextData> &context,
++ const ReplacedContexts &replacedContexts)
++ {
++ const auto it = replacedContexts.constFind(context.data());
++ return it == replacedContexts.constEnd() ? context : it->newContext;
++ }
++
++ // The contexts of the composite levels of object, in the order of collectCompositeLevels().
++ static QVarLengthArray<QQmlRefPointer<QQmlContextData>, 4>
++ levelContexts(QObject *object, const QQmlRefPointer<QQmlContextData> &outerContext)
++ {
++ QVarLengthArray<QQmlRefPointer<QQmlContextData>, 4> contexts;
++ for (QQmlRefPointer<QQmlContextData> ctx(QQmlData::get(object)->context); ctx;
++ ctx = ctx->linkedContext()) {
++ if (ctx != outerContext && ctx->contextObject() == object)
++ contexts.append(ctx);
++ }
++
++ // The linked contexts are ordered from the deepest base type to the most derived one.
++ std::reverse(contexts.begin(), contexts.end());
++
++ return contexts;
++ }
++
++ // cuIndex is not necessarily the "outermost" index. There may be levels above oldUnit.
++ // Those have to be preserved/rebuilt.
++ static void rebuildObject(QObject *object, int cuIndex,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit,
++ ReplacedContexts *replacedContexts)
++ {
++ // If the object's index doesn't exist in the new CU, it's obsolete.
++ if (cuIndex >= newUnit->objectCount())
++ return;
++
++ QQmlData *ddata = QQmlData::get(object);
++ Q_ASSERT(ddata);
++
++ QQmlRefPointer<QQmlContextData> outerContext =
++ QQmlRefPointer<QQmlContextData>(ddata->outerContext);
++
++ // If the object has no context, or is scheduled for deletion, it's half-dead already.
++ if (!ddata->context || !outerContext || !outerContext->isValid() || ddata->isQueuedForDeletion)
++ return;
++
++ CompositeLevel instanceLevel{ ddata->compilationUnit,
++ ddata->compilationUnit == oldUnit ? newUnit
++ : ddata->compilationUnit,
++ ddata->cuObjectIndex, QString(), outerContext };
++
++ // If the object doesn't exist anymore in the new CU it will be deleted via GC.
++ // Nothing to do here.
++ if (instanceLevel.objectIndex >= instanceLevel.newCu->objectCount())
++ return;
++
++ std::vector<CompositeLevel> levels = collectCompositeLevels(instanceLevel, oldUnit, newUnit);
++
++ // Build the set of compilation units that participate in this rebuild.
++ // Bindings from these CUs are "internal" and will be re-created by repopulateBindings.
++ std::vector<CompositeLevel> internalUnits;
++ internalUnits.push_back(instanceLevel);
++ for (const auto &level : levels)
++ internalUnits.push_back(level);
++
++ BindingPatchContext patchCtx(object, ddata->compilationUnit, ddata->cuObjectIndex);
++ QDuplicateTracker<QObject *> seenChildren;
++ patchCtx.stashExternalState(internalUnits, &seenChildren);
++ // Collect the CUs whose children will be recreated by repopulateBindings.
++ // This is oldUnit (being replaced) and the composite-level CUs.
++ // NOT newUnit (already-rebuilt objects pointing here must be preserved)
++ // and NOT instanceLevel.cu (its repopulateBindings only sets bindings, not children).
++ std::vector<QQmlRefPointer<QV4::ExecutableCompilationUnit>> unitsToUnparent;
++ unitsToUnparent.push_back(oldUnit);
++ for (const auto &level : levels)
++ unitsToUnparent.push_back(level.oldCu);
++ patchCtx.reset(unitsToUnparent, internalUnits);
++
++ QV4::ExecutionEngine *v4 = newUnit->engine;
++ Q_ASSERT(v4);
++ QQmlEnginePrivate *enginePrivate = QQmlEnginePrivate::get(v4);
++ Q_ASSERT(enginePrivate);
++
++ const QVarLengthArray<QQmlRefPointer<QQmlContextData>, 4> oldLevelContexts =
++ levelContexts(object, outerContext);
++
++ if (outerContext->contextObject() == object) {
++ const QQmlRefPointer<QQmlContextData> oldOuterContext = outerContext;
++ oldOuterContext->setContextObject(nullptr);
++ outerContext = enginePrivate->createComponentRootContext(
++ instanceLevel.newCu, currentContext(oldOuterContext->parent(), *replacedContexts),
++ instanceLevel.objectIndex);
++ outerContext->setContextObject(object);
++ instanceLevel.context = outerContext;
++ replacedContexts->insert(oldOuterContext.data(), { oldOuterContext, outerContext });
++ }
++
++ for (QQmlRefPointer<QQmlContextData> ctx(ddata->context); ctx; ctx = ctx->linkedContext()) {
++ if (ctx->contextObject() == object)
++ ctx->setContextObject(nullptr);
++ }
++
++ ddata->clear();
++
++ QObjectPrivate *objectPrivate = QObjectPrivate::get(object);
++ delete std::exchange(objectPrivate->metaObject, nullptr);
++
++ QQmlRefPointer<QQmlContextData> levelContext = outerContext;
++ qsizetype replacedLevels = 0;
++ for (qsizetype i = 0, end = levels.size(); i < end; ++i) {
++ CompositeLevel &level = levels[i];
++ levelContext = level.context = enginePrivate->createComponentRootContext(
++ level.newCu, levelContext, level.objectIndex);
++ levelContext->setContextObject(object);
++
++ // The base type chain may have changed. Only match the old contexts up to the first
++ // level that differs.
++ if (i >= oldLevelContexts.size() || i != replacedLevels)
++ continue;
++ const QQmlRefPointer<QQmlContextData> &oldLevelContext = oldLevelContexts[i];
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> oldLevelCu =
++ oldLevelContext->typeCompilationUnit();
++ if ((oldLevelCu == oldUnit ? newUnit : oldLevelCu) != level.newCu)
++ continue;
++ replacedContexts->insert(oldLevelContext.data(), { oldLevelContext, levelContext });
++ ++replacedLevels;
++ }
++
++ if (outerContext->contextObject() == object) {
++ ddata->ownContext = outerContext;
++ ddata->context = outerContext.data();
++ if (!levels.empty())
++ ddata->context->setLinkedContext(levels.front().context);
++ } else if (!levels.empty()) {
++ ddata->ownContext = levels.back().context;
++ ddata->context = ddata->ownContext.data();
++ if (levels.size() > 1)
++ ddata->context->setLinkedContext(levels.front().context);
++ } else {
++ // Non-root child: doesn't own a context. Re-link to the parent context.
++ ddata->context = outerContext.data();
++ }
++
++ // Build the VME meta-object chain base-first, relinking each level's property cache to the
++ // actual (possibly freshly reloaded) parent cache we just used, so the whole chain's offsets
++ // stay consistent even when a composite base type's layout changed on reload.
++ QQmlPropertyCache::ConstPtr parentCache;
++ for (auto it = levels.crbegin(), end = levels.crend(); it != end; ++it) {
++ it->context->addOwnedObject(ddata);
++ QQmlPropertyCache::ConstPtr cache = relinkCache(it->newCu, it->objectIndex, parentCache);
++ if (it->newCu->propertyCachesPtr()->needsVMEMetaObject(it->objectIndex))
++ new QQmlVMEMetaObject(v4, object, cache, it->newCu, it->objectIndex);
++ parentCache = cache;
++ }
++
++ outerContext->addOwnedObject(ddata);
++ if (QQmlPropertyCacheVector *caches = instanceLevel.newCu->propertyCachesPtr();
++ caches->count() > instanceLevel.objectIndex) {
++ QQmlPropertyCache::ConstPtr cache =
++ relinkCache(instanceLevel.newCu, instanceLevel.objectIndex, parentCache);
++ if (caches->needsVMEMetaObject(instanceLevel.objectIndex))
++ new QQmlVMEMetaObject(v4, object, cache, instanceLevel.newCu, instanceLevel.objectIndex);
++ }
++
++ // Repopulate bindings at each composite level (deepest first).
++ // This sets up functions, evaluates bindings (creating child objects), etc.
++ // The object may get queued for deletion as result of some bindings.
++ // In that case we have to abort.
++ for (auto it = levels.crbegin(), end = levels.crend(); it != end && !ddata->isQueuedForDeletion;
++ ++it) {
++ QQmlObjectCreator creator(it->context, it->newCu, outerContext, it->icName, nullptr);
++ creator.repopulateBindings(it->objectIndex, object, it->context,
++ QQmlObjectCreator::InitFlag::IsContextObject
++ | QQmlObjectCreator::InitFlag::IsDocumentRoot);
++
++ QQmlInstantiationInterrupt interrupt;
++ creator.finalize(interrupt);
++ }
++
++ // The object may get queued for deletion as result of some bindings.
++ // In that case don't touch it any further.
++ if (!ddata->isQueuedForDeletion) {
++ // Repopulate bindings at the instance level in the parent CU.
++ QQmlObjectCreator creator(instanceLevel.context, instanceLevel.newCu, outerContext, QString(),
++ nullptr);
++ creator.repopulateBindings(instanceLevel.objectIndex, object, outerContext,
++ QQmlObjectCreator::InitFlag::None);
++ QQmlInstantiationInterrupt interrupt;
++ creator.finalize(interrupt);
++
++ // Restore externally set bindings and values that were stashed before reset.
++ // First refresh child object pointers — they may have been replaced during rebuild.
++ patchCtx.refreshObjects();
++ patchCtx.restoreExternalState();
++ }
++ }
++
++ enum class BindingKind { Literal, Script, Translation, Unpatchable };
++ static BindingKind bindingKind(const QV4::CompiledData::Binding *binding)
++ {
++ switch (binding->type()) {
++ case QV4::CompiledData::Binding::Type_Script:
++ return BindingKind::Script;
++ case QV4::CompiledData::Binding::Type_Translation:
++ case QV4::CompiledData::Binding::Type_TranslationById:
++ return BindingKind::Translation;
++ case QV4::CompiledData::Binding::Type_Number:
++ case QV4::CompiledData::Binding::Type_Boolean:
++ case QV4::CompiledData::Binding::Type_String:
++ case QV4::CompiledData::Binding::Type_Null:
++ return BindingKind::Literal;
++ default:
++ return BindingKind::Unpatchable;
++ }
++ }
++
++ // A trivial diff is one we can apply without rebuilding any VME meta-object and without
++ // adding or removing objects: only existing bindings and binding-expression bodies change. Such a
++ // diff is patched in place (see patchInPlace()). Everything else falls back to rebuilding roots.
++ static bool changeIsTrivial(const QV4::CompiledData::Change &change,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ using ChangeType = QV4::CompiledData::ChangeType;
++ switch (change.type) {
++ // Source-location-only changes have no runtime effect.
++ case ChangeType::AliasLocationChanged:
++ case ChangeType::BindingLocationChanged:
++ case ChangeType::EnumLocationChanged:
++ case ChangeType::FunctionLocationChanged:
++ case ChangeType::ImportLocationChanged:
++ case ChangeType::InlineComponentLocationChanged:
++ case ChangeType::ObjectLocationChanged:
++ case ChangeType::PropertyLocationChanged:
++ case ChangeType::SignalLocationChanged:
++ // Internal table changes that are byproducts of recompiling expressions. They are picked up
++ // when we translate functions and remap compilation units; no structure changes.
++ case ChangeType::UnitMetadataChanged:
++ case ChangeType::ConstantAdded:
++ case ChangeType::ConstantChanged:
++ case ChangeType::ConstantRemoved:
++ case ChangeType::StringDataAdded:
++ case ChangeType::StringDataChanged:
++ case ChangeType::StringDataRemoved:
++ case ChangeType::LookupAdded:
++ case ChangeType::LookupChanged:
++ case ChangeType::LookupRemoved:
++ case ChangeType::RegExpAdded:
++ case ChangeType::RegExpChanged:
++ case ChangeType::RegExpRemoved:
++ case ChangeType::ClassAdded:
++ case ChangeType::ClassChanged:
++ case ChangeType::ClassRemoved:
++ case ChangeType::BlockAdded:
++ case ChangeType::BlockChanged:
++ case ChangeType::BlockRemoved:
++ case ChangeType::TemplateObjectAdded:
++ case ChangeType::TemplateObjectChanged:
++ case ChangeType::TemplateObjectRemoved:
++ case ChangeType::JSClassAdded:
++ case ChangeType::JSClassChanged:
++ case ChangeType::JSClassRemoved:
++ case ChangeType::TranslationDataAdded:
++ case ChangeType::TranslationDataChanged:
++ case ChangeType::TranslationDataRemoved:
++ return true;
++ case ChangeType::FunctionChanged:
++ // A recompiled function body at a stable index. Binding/handler expressions pick up the new
++ // body via refreshBindings(), VME methods via refreshVmeMethods(). Neither needs a rebuild,
++ // so a function change is trivial regardless of whether the function backs a binding or a
++ // method.
++ return true;
++ case ChangeType::BindingChanged: {
++ Q_ASSERT(change.objectIndex >= 0);
++ Q_ASSERT(change.objectIndex < oldUnit->objectCount());
++ Q_ASSERT(change.objectIndex < newUnit->objectCount());
++
++ const QV4::CompiledData::Object *oldObj = oldUnit->objectAt(change.objectIndex);
++ Q_ASSERT(change.index < oldObj->nBindings);
++ const QV4::CompiledData::Binding *oldBinding = oldObj->bindingTable() + change.index;
++
++ const QV4::CompiledData::Object *newObj = newUnit->objectAt(change.objectIndex);
++ Q_ASSERT(change.index < newObj->nBindings);
++ const QV4::CompiledData::Binding *newBinding = newObj->bindingTable() + change.index;
++
++ const BindingKind oldKind = bindingKind(oldBinding);
++ const BindingKind newKind = bindingKind(newBinding);
++ if (oldKind == BindingKind::Unpatchable || newKind == BindingKind::Unpatchable)
++ return false;
++
++ // We cannot swap a binding for one of a different kind, yet: turning a literal into a
++ // script or translation binding (or vice versa) would have to install or drop a live
++ // binding, and we cannot recompile a script binding into a translation binding either.
++ // TODO: Fix this.
++ if (oldKind != newKind)
++ return false;
++
++ // A BindingChanged at a stable index can also mean the binding was moved to a different
++ // target property (its propertyNameIndex changed). In-place patching cannot relocate a
++ // binding: it would have to remove it from the old property and install it on the new one.
++ // That is structural, so fall back to the rebuild path.
++
++ return BindingPatchContext::targetPropertyName(oldUnit, change.objectIndex, oldBinding)
++ == BindingPatchContext::targetPropertyName(newUnit, change.objectIndex, newBinding);
++ }
++ default:
++ // ObjectAdded/Removed/Changed, Binding Added/Removed, Property/Signal/Alias/Enum changes,
++ // Function Added/Removed, Import/InlineComponent/RequiredPropertyExtraData changes:
++ // structural, need a rebuild.
++ return false;
++ }
++ }
++
++ static bool isTrivialDiff(const QV4::CompiledData::CompilationUnitDiff &diff,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ return std::all_of(diff.changes.cbegin(), diff.changes.cend(),
++ [&](const QV4::CompiledData::Change &change) {
++ return changeIsTrivial(change, oldUnit, newUnit);
++ });
++ }
++
++ // Re-apply changed literal bindings. A literal value is written only if the property still holds
++ // the value the old unit assigned; anything else is an external override we must leave untouched.
++ // Changed script bindings carry no literal value and are handled by function translation instead.
++ //
++ // The binding may live on a value-type group sub-object (font.pixelSize) or an attached object
++ // (Keys.enabled), which has no standalone QObject at its compilation-unit index. We use
++ // BindingPatchContext to map every compilation-unit object index reachable from a live instance to
++ // the owning QObject and the property-name prefix to address it.
++ static void patchConstantBindings(const std::vector<QObject *> &objects,
++ const QV4::CompiledData::CompilationUnitDiff &diff,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ for (QObject *object : objects) {
++ // Skip half-dead objects, mirroring rebuildObject(): an invalidated context means the
++ // object is on its way out and must not be patched.
++ QQmlData *ddata = QQmlData::get(object);
++ if (!ddata->context || !ddata->outerContext || !ddata->outerContext->isValid()
++ || ddata->isQueuedForDeletion) {
++ continue;
++ }
++
++ QVarLengthArray<BindingPatchContext, 4> contexts;
++ for (int index : objectIndices(object, oldUnit))
++ contexts.append(BindingPatchContext(object, oldUnit, index));
++
++ for (const QV4::CompiledData::Change &change : diff.changes) {
++ if (change.type != QV4::CompiledData::ChangeType::BindingChanged)
++ continue;
++
++ for (BindingPatchContext &context : contexts) {
++ if (context.applyBindingChange(newUnit, change))
++ break;
++ }
++ }
++ }
++ }
++
++ // Point every live object that still references oldUnit at newUnit, in both its ddata and its
++ // VME meta-object chain. Used after in-place patching, which keeps all object indices stable.
++ //
++ // The ddata compilation unit and the VME chain are remapped independently: a composite-type
++ // instance can carry oldUnit in its VME chain while its ddata->compilationUnit is a different
++ // executable unit (the "topmost", possibly inaddressible, instantiation).
++ static void remapObjectsToNewUnit(const std::vector<QObject *> &objects,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ for (QObject *object : objects) {
++ QQmlData *ddata = QQmlData::get(object);
++
++ // A QQmlComponent (e.g. an explicit or implicit `delegate:`) caches the compilation unit it
++ // instantiates from. Remap it so future create() calls produce instances from newUnit.
++ if (QQmlComponent *component = qobject_cast<QQmlComponent *>(object)) {
++ QQmlComponentPrivate *cp = QQmlComponentPrivate::get(component);
++ if (cp->compilationUnit() == oldUnit)
++ cp->setCompilationUnit(newUnit);
++ }
++
++ // Remap the ddata compilation unit if it points at oldUnit. An object whose index is out
++ // of range in the new CU is obsolete (it belonged to the old type definition); leave its
++ // ddata alone and let the VME nulling below retire it.
++ if (ddata->compilationUnit == oldUnit && ddata->cuObjectIndex < newUnit->objectCount())
++ ddata->compilationUnit = newUnit;
++
++ if (!ddata->hasVMEMetaObject)
++ continue;
++
++ // Remap (or retire) every VME meta-object in the chain that points at oldUnit.
++ auto *mainVme = static_cast<QQmlVMEMetaObject *>(QObjectPrivate::get(object)->metaObject);
++ for (QQmlVMEMetaObject *vmeMeta = mainVme; vmeMeta;
++ vmeMeta = vmeMeta->parentVMEMetaObject()) {
++ if (vmeMeta->compilationUnit() != oldUnit)
++ continue;
++ if (vmeMeta->qmlObjectId() < newUnit->objectCount()) {
++ vmeMeta->setCompilationUnit(newUnit);
++
++ // Give the live instance the reloaded type's identity. The instance must present
++ // newUnit's property cache.
++ const QQmlPropertyCache::ConstPtr newCache =
++ newUnit->propertyCachesPtr()->at(vmeMeta->qmlObjectId());
++ if (newCache) {
++ vmeMeta->setPropertyCache(newCache);
++ if (vmeMeta == mainVme)
++ ddata->propertyCache = newCache;
++ }
++ } else {
++ // Obsolete: null it so stale alias lookups (triggered by refreshBindings) safely
++ // return nullptr from findCompiledObject() instead of asserting.
++ vmeMeta->setCompilationUnit(nullptr);
++ }
++ }
++ }
++ }
++
++ // Returns true if the object is instantiated as a component root of the old unit that we can
++ // rebuild in place (see canRebuildComponentRootInPlace()), or as a component root of a different,
++ // unchanged unit. The latter is rebuilt against its own unit. Otherwise, for example if the object
++ // is not a component root at all or not even created from QML, return false.
++ static bool isRebuildableComponentRoot(
++ QObject *object,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ bool foundComponentRoot = false;
++ for (int index : objectIndices(object, oldUnit)) {
++ if (index >= oldUnit->objectCount() || !isComponentRoot(oldUnit, index))
++ continue;
++ if (!canRebuildComponentRootInPlace(oldUnit, newUnit, index))
++ return false;
++ foundComponentRoot = true;
++ }
++
++ if (foundComponentRoot)
++ return true;
++
++ const QQmlData *ddata = QQmlData::get(object);
++ return ddata && ddata->compilationUnit && ddata->compilationUnit != oldUnit
++ && isComponentRoot(ddata->compilationUnit, ddata->cuObjectIndex);
++ }
++
++ // A component root whose non-composite base type changed or that carries deferred bindings cannot
++ // be rebuilt in place. Instead we travel the scope hierarchy upwards to the enclosing component
++ // root that instantiates it and rebuild that: its reset() + repopulateBindings() recreates the
++ // problematic object from scratch, as a fresh QObject. If that enclosing root is problematic, too,
++ // we keep travelling up. Returns the object to rebuild, or nullptr if we reach the root scope
++ // without finding a rebuildable enclosing root.
++ static QObject *outerRebuildTarget(
++ QObject *object,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ Q_ASSERT(object);
++
++ const QQmlData *ddata = QQmlData::get(object);
++ if (!ddata)
++ return nullptr;
++
++ // Walk up the context hierarchy. The root of a component instance is the context object of
++ // its own context. Contexts may also have no context object or one that is not a component
++ // root at all (e.g. a delegate model's item). If we reach the root context, we give up.
++ for (QQmlRefPointer<QQmlContextData> context(ddata->outerContext); context;
++ context = context->parent()) {
++ QObject *outer = context->contextObject();
++ if (outer && outer != object && isRebuildableComponentRoot(outer, oldUnit, newUnit))
++ return outer;
++ }
++
++ return nullptr;
++ }
++
++ // TODO: This is dangerous. We are manipulating compilation units exposed to multiple
++ // engines on potentially multiple threads.
++ void redirectResolvedTypeReferences(
++ QV4::ExecutionEngine *engine,
++ const QQmlRefPointer<QV4::CompiledData::CompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::CompiledData::CompilationUnit> &newUnit)
++ {
++ const auto units = engine->compilationUnits();
++ for (const auto &cu : units) {
++ for (auto *typeRef : std::as_const(cu->baseCompilationUnit()->resolvedTypes)) {
++ if (typeRef->isSelfReference())
++ continue;
++ if (typeRef->compilationUnit() != oldUnit)
++ continue;
++
++ typeRef->setCompilationUnit(newUnit);
++
++ QQmlPropertyCache::ConstPtr newCache;
++ const QQmlType type = typeRef->type();
++ if (type.isInlineComponent()) {
++ if (const int icId = newUnit->inlineComponentId(type.elementName()); icId >= 0)
++ newCache = newUnit->propertyCaches.at(icId);
++ } else {
++ newCache = newUnit->rootPropertyCache();
++ }
++
++ if (!newCache)
++ continue;
++
++ const QQmlPropertyCache::ConstPtr oldCache = typeRef->typePropertyCache();
++ typeRef->setTypePropertyCache(newCache);
++ relinkDerivedCaches(cu, oldCache, newCache);
++ }
++ }
++ }
++
++ // Re-create the VME method function objects from newUnit so that an object's methods follow the
++ // unit remap, mirroring what refreshBindings() does for QQmlJavaScriptExpression-based bindings.
++ static void refreshVmeMethods(const std::vector<QObject *> &objects,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ QV4::ExecutionEngine *v4 = newUnit->engine;
++ QV4::Scope scope(v4);
++ QV4::ScopedValue function(scope);
++
++ for (QObject *object : objects) {
++ QQmlData *ddata = QQmlData::get(object);
++ if (!ddata || !ddata->hasVMEMetaObject)
++ continue;
++
++ auto *mainVme = static_cast<QQmlVMEMetaObject *>(QObjectPrivate::get(object)->metaObject);
++ for (QQmlVMEMetaObject *vme = mainVme; vme; vme = vme->parentVMEMetaObject()) {
++ const auto cu = vme->compilationUnit();
++ if (cu != newUnit)
++ continue;
++
++ const QQmlRefPointer<QQmlContextData> context = vme->contextData();
++ if (!context)
++ continue;
++
++ const int objectIndex = vme->qmlObjectId();
++ if (objectIndex < 0 || objectIndex >= cu->objectCount())
++ continue;
++
++ const QV4::CompiledData::Object *obj = cu->objectAt(objectIndex);
++ const QQmlPropertyCache::ConstPtr cache = cu->propertyCachesPtr()->at(objectIndex);
++ if (!cache)
++ continue;
++
++ QV4::Scoped<QV4::QmlContext> qmlContext(
++ scope, QV4::QmlContext::create(v4->rootContext(), context, object));
++
++ const quint32_le *functionIdx = obj->functionOffsetTable();
++ for (quint32 i = 0; i < obj->nFunctions; ++i, ++functionIdx) {
++ QV4::Function *runtimeFunction = cu->runtimeFunctions[*functionIdx];
++ const QString name = runtimeFunction->name()->toQString();
++
++ const QQmlPropertyData *property = cache->property(name, object, context);
++ if (!property || !property->isVMEFunction())
++ continue;
++
++ // Mirror QQmlObjectCreator::setupFunctions(): generators need their own creator.
++ function = runtimeFunction->isGenerator()
++ ? QV4::GeneratorFunction::create(qmlContext, runtimeFunction)
++ : QV4::FunctionObject::createScriptFunction(qmlContext, runtimeFunction);
++ mainVme->setVmeMethod(property->coreIndex(), function);
++ }
++ }
++ }
++ }
++
++ PatchResult applyDiff(std::vector<QObject *> &objects,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ // Ensure the new CU's runtime data (strings, lookups, functions) is populated.
++ if (!newUnit->runtimeStrings)
++ newUnit->populate();
++
++ // Fast path: if only existing bindings changed -- nothing structural about any VME
++ // meta-object, and no objects added or removed -- patch the affected objects in place. We
++ // leave every object and its VME meta-object where it is, re-apply the changed literal
++ // bindings (patchConstantBindings), point the objects at newUnit (remapObjectsToNewUnit), and
++ // let the in-place refreshBindings() translate the still-live expressions' functions to
++ // newUnit. Because no functions are added or removed in a trivial diff, function indices are
++ // stable, which is what makes that same-index translation correct.
++ const QV4::CompiledData::CompilationUnitDiff diff =
++ QV4::CompiledData::diffCompilationUnits(oldUnit->unitData(), newUnit->unitData());
++ if (diff.success && isTrivialDiff(diff, oldUnit, newUnit)) {
++ patchConstantBindings(objects, diff, oldUnit, newUnit);
++ remapObjectsToNewUnit(objects, oldUnit, newUnit);
++ refreshVmeMethods(objects, newUnit);
++ return PatchResult::PatchedInPlace;
++ }
++
++ // Otherwise we rebuild whole component roots: the document root (index 0) and any
++ // inline-component roots. We don't touch other objects directly. Rebuilding a root runs a
++ // full reset() + repopulateBindings() that cascades down the entire instantiation (and
++ // through its composite base levels), recreating every object below it. Since every
++ // non-root object is, by construction, a descendant of a component root, this is
++ // sufficient. A component root that cannot be rebuilt in place - its C++ base type changed, or
++ // it carries deferred bindings (see below) - is handled by rebuilding the enclosing component
++ // root instead, which may live in a different compilation unit and recreates the root as a
++ // fresh object (of the new C++ class, with its deferred bindings armed and executed).
++ //
++ // A consequence worth remembering: because every live object is recreated, every
++ // QQmlJavaScriptExpression on those objects is recreated too, freshly bound to newUnit. By
++ // the time refreshBindings() runs, the only expressions still referencing oldUnit are the
++ // dead, detached leftovers of the resets. That is why the rebuild path's refreshBindings()
++ // can simply disable (null) them instead of remapping them to newUnit.
++ // A rebuild target carries the compilation units to rebuild it with. Usually that's oldUnit ->
++ // newUnit. But when we travel up to an enclosing component root in a *different* compilation
++ // unit (because a root's base type changed), that unit is itself unchanged: we rebuild it
++ // against itself (a full re-instantiation of its children) after redirecting the resolved type
++ // references, so the problematic object is recreated with its new C++ base type.
++ std::vector<RebuildTarget> rebuild;
++ QSet<QObject *> rebuildSet;
++ bool redirectedTypes = false;
++
++ const auto addRebuild = [&](QObject *object, int index,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldCu,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newCu) {
++ if (rebuildSet.contains(object))
++ return;
++ rebuildSet.insert(object);
++ rebuild.push_back({ object, index, oldCu, newCu });
++ };
++
++ for (QObject *object : objects) {
++ const QVarLengthArray<int, 4> indices = objectIndices(object, oldUnit);
++ for (int index : indices) {
++ // Objects instantiated by an enclosing component (indices beyond the CU) are recreated
++ // when that enclosing root is rebuilt, so we don't record them here. Neither do we
++ // record any other objects but component roots. Instances of inner components are not
++ // recreated by rebuilding the enclosing component. Therefore, we record their roots.
++ if (index >= oldUnit->objectCount() || !isComponentRoot(oldUnit, index))
++ continue;
++
++ // A component root whose own non-composite base type changed, which carries deferred
++ // bidnings, or which isn't a component root anymore cannot be rebuilt in place. Rebuild
++ // the enclosing component root instead, so that the object is recreated from scratch
++ // as an instance of the new C++ class with new deferred bindings. A surviving instance
++ // of an inner component stays on oldUnit then. Travelling up the scope hierarchy this
++ // way only fails once we hit the root scope.
++ if (!canRebuildComponentRootInPlace(oldUnit, newUnit, index)) {
++ QObject *outer = outerRebuildTarget(object, oldUnit, newUnit);
++ if (!outer)
++ return PatchResult::Failed;
++
++ // The enclosing root may recreate the object from a different compilation unit
++ // (the object was instantiated as an external type). Point that unit at newUnit
++ // first, so the recreated object gets the new definition.
++ if (!redirectedTypes) {
++ redirectResolvedTypeReferences(newUnit->engine, oldUnit->baseCompilationUnit(),
++ newUnit->baseCompilationUnit());
++ redirectedTypes = true;
++ }
++
++ // Rebuild the enclosing root against its own compilation unit (or newUnit, if that
++ // root lives in oldUnit itself, e.g. an inline component). The unchanged outer unit
++ // re-instantiates its children, recreating the problematic object.
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> outerOld =
++ QQmlData::get(outer)->compilationUnit;
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> outerNew =
++ outerOld->baseCompilationUnit() == oldUnit->baseCompilationUnit()
++ ? newUnit
++ : outerOld;
++ addRebuild(outer, QQmlData::get(outer)->cuObjectIndex, outerOld, outerNew);
++ break;
++ }
++
++ addRebuild(object, indices.first(), oldUnit, newUnit);
++ break;
++ }
++ }
++
++ // Sort by ascending cuIndex so that parent objects are rebuilt before their
++ // children. A parent's reset() properly retires children (they still point to
++ // oldUnit) and repopulateBindings recreates them. This avoids leaking orphaned
++ // children and naturally handles cases where the context needs more ID slots.
++ std::sort(rebuild.begin(), rebuild.end(),
++ [](const RebuildTarget &a, const RebuildTarget &b) { return a.index < b.index; });
++
++ // Pre-compute which objects to skip: if an ancestor is also in the rebuild
++ // list, the child will be properly retired and recreated during the ancestor's
++ // rebuild. Rebuilding it individually would be wasted work on a stale pointer.
++ QSet<QObject *> skip;
++ for (const RebuildTarget &target : rebuild) {
++ const QObjectList &children = target.object->children();
++ for (QObject *child : children)
++ skip.insert(child);
++ }
++
++ ReplacedContexts replacedContexts;
++ for (const RebuildTarget &target : rebuild) {
++ if (skip.contains(target.object))
++ continue;
++
++ rebuildObject(target.object, target.index, target.oldCu, target.newCu, &replacedContexts);
++ }
++
++ // Everything lexically inside the rebuilt components has been recreated or rebuilt now. Whatever
++ // was instantiated by oldUnit and survived without being rebuilt is obsolete. We cannot remap it
++ // to newUnit by index since indices may have shifted. Retire it.
++ for (QObject *object : objects) {
++ const QQmlData *ddata = QQmlData::get(object);
++ if (ddata->compilationUnit != oldUnit || ddata->isQueuedForDeletion)
++ continue;
++ BindingPatchContext::clearBindingsRecursive(object);
++ BindingPatchContext::retireObject(object);
++ }
++
++ return PatchResult::Rebuilt;
++ }
++
++ // Translate a still-live expression's function from oldUnit to the function at the same index in
++ // newUnit, or clear it if there is no newUnit. Expressions whose function does not point into
++ // oldUnit are left untouched. Same-index translation is valid because we only do this with trivial
++ // diffs that neither add nor remove functions.
++ // Returns true if the resulting function is valid afterwards (and should be re-evaluated)
++ static bool
++ translateExpressionFunction(QQmlJavaScriptExpression *expr,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ QV4::Function *f = expr->function();
++ if (!f)
++ return false;
++
++ if (f->executableCompilationUnit() != oldUnit.data())
++ return true;
++
++ if (newUnit) {
++ const qsizetype index = oldUnit->runtimeFunctions.indexOf(f);
++ if (index >= 0 && index < newUnit->runtimeFunctions.size())
++ expr->setFunction(newUnit->runtimeFunctions[index]);
++ } else {
++ expr->setFunction(nullptr);
++ return false;
++ }
++
++ return true;
++ }
++
++ static void translateAndRefreshExpressionsRecursive(
++ const QQmlRefPointer<QQmlContextData> &context,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ for (auto child = context->childContexts(); child; child = child->nextChild())
++ translateAndRefreshExpressionsRecursive(child, oldUnit, newUnit);
++
++ for (auto *expr = context->expressions(); expr; expr = expr->nextExpression()) {
++ if (translateExpressionFunction(expr, oldUnit, newUnit))
++ expr->refresh();
++ }
++ }
++
++ void refreshBindings(const QQmlRefPointer<QV4::ExecutableCompilationUnit> &oldUnit,
++ const QQmlRefPointer<QV4::ExecutableCompilationUnit> &newUnit)
++ {
++ translateAndRefreshExpressionsRecursive(
++ QQmlContextData::get(oldUnit->engine->qmlEngine()->rootContext()), oldUnit, newUnit);
++ }
++
++ } // namespace QQmlPreview
++
++ QT_END_NAMESPACE