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 "qqmlpreviewdiff_p.h"
++
++ #include <private/qv4staticvalue_p.h>
++
++ #include <QtCore/qmap.h>
++ #include <QtCore/qscopedvaluerollback.h>
++ #include <QtCore/qset.h>
++
++ #include <cstring>
++
++ QT_BEGIN_NAMESPACE
++
++ // IMPORTANT:
++ //
++ // If you update the data structures in qv4compileddata_p.h, then you also need to
++ // update the comparison functions below. Only after making sure the comparisons
++ // are fine, bump the version in the static_assert.
++ static_assert(QV4_DATA_STRUCTURE_VERSION == 0x53);
++
++ namespace QV4::CompiledData {
++
++ using Constant = quint64_le;
++ using StringData = QString;
++
++ template <typename Data>
++ Data extractData(const Data &data)
++ {
++ return data;
++ }
++
++ static EnumHunk extractData(const Enum &e)
++ {
++ EnumHunk data;
++ data.data = e;
++ for (const EnumValue *v = e.enumValuesBegin(); v != e.enumValuesEnd(); ++v)
++ data.values.append(*v);
++ return data;
++ }
++
++ static SignalHunk extractData(const Signal &s)
++ {
++ SignalHunk data;
++ data.data = s;
++ for (quint32 i = 0; i < s.nParameters; ++i)
++ data.parameters.append(*s.parameterAt(i));
++ return data;
++ }
++
++ static FunctionHunk extractData(const Function &func)
++ {
++ FunctionHunk data;
++ data.data = func;
++
++ for (quint16 i = 0, end = func.nFormals; i != end; ++i)
++ data.formals.append(func.formalsTable()[i]);
++
++ for (quint16 i = 0, end = func.nLocals; i != end; ++i)
++ data.locals.append(func.localsTable()[i]);
++
++ for (quint16 i = 0, end = func.nLineAndStatementNumbers; i != end; ++i)
++ data.lineAndStatementNumbers.append(func.lineAndStatementNumberTable()[i]);
++
++ for (quint32 i = 0, end = func.nLabelInfos; i != end; ++i)
++ data.labelInfos.append(func.labelInfoTable()[i]);
++
++ data.code = QByteArray(func.code(), func.codeSize);
++ return data;
++ }
++
++ static ObjectHunk extractData(const Object &obj)
++ {
++ ObjectHunk data;
++ data.data = obj;
++
++ for (quint32 i = 0; i < obj.nFunctions; ++i)
++ data.functionIndices.append(extractData(obj.functionOffsetTable()[i]));
++
++ for (quint32 i = 0; i < obj.nBindings; ++i)
++ data.bindings.append(extractData(obj.bindingTable()[i]));
++
++ for (quint32 i = 0; i < obj.nProperties; ++i)
++ data.properties.append(extractData(obj.propertyTable()[i]));
++
++ for (quint32 i = 0; i < obj.nAliases; ++i)
++ data.aliases.append(extractData(obj.aliasTable()[i]));
++
++ for (quint32 i = 0; i < obj.nSignals; ++i)
++ data.sigs.append(extractData(*obj.signalAt(i)));
++
++ for (quint32 i = 0; i < obj.nEnums; ++i)
++ data.enums.append(extractData(*obj.enumAt(i)));
++
++ for (quint32 i = 0; i < obj.nNamedObjectsInComponent; ++i) {
++ data.namedObjectsInComponentIndices.append(
++ extractData(obj.namedObjectsInComponentTable()[i]));
++ }
++
++ for (quint32 i = 0; i < obj.nInlineComponents; ++i)
++ data.inlineComponents.append(extractData(obj.inlineComponentTable()[i]));
++
++ for (quint32 i = 0; i < obj.nRequiredPropertyExtraData; ++i)
++ data.requiredPropertyExtraData.append(extractData(obj.requiredPropertyExtraDataTable()[i]));
++
++ return data;
++ }
++
++ static UnitHunk extractData(const Unit &unit)
++ {
++ return unit;
++ }
++
++ static ClassHunk extractData(const Class &cls)
++ {
++ ClassHunk data;
++ data.data = cls;
++ const Method *methods = cls.methodTable();
++ for (quint32 i = 0, end = cls.nStaticMethods + cls.nMethods; i < end; ++i)
++ data.methods.append(methods[i]);
++ return data;
++ }
++
++ static TemplateObjectHunk extractData(const TemplateObject &to)
++ {
++ TemplateObjectHunk data;
++ data.size = to.size;
++ const quint32_le *strings = reinterpret_cast<const quint32_le *>(&to + 1);
++ for (quint32 i = 0; i < 2u * to.size; ++i)
++ data.strings.append(strings[i]);
++ return data;
++ }
++
++ static JsClassHunk extractData(const JSClass &jsClass)
++ {
++ JsClassHunk data;
++ data.nMembers = jsClass.nMembers;
++ const JSClassMember *members = reinterpret_cast<const JSClassMember *>(&jsClass + 1);
++ for (quint32 i = 0; i < jsClass.nMembers; ++i)
++ data.members.append(members[i]);
++ return data;
++ }
++
++ static BlockHunk extractData(const Block &block)
++ {
++ BlockHunk data;
++ data.data = block;
++ for (quint32 i = 0; i < block.nLocals; ++i)
++ data.locals.append(block.localsTable()[i]);
++ return data;
++ }
++
++ // location extraction
++
++ template <typename T, typename L = void>
++ struct LocationExtractor
++ {
++ static bool extract(const T &) { return false; }
++ };
++
++ template <typename T>
++ struct LocationExtractor<T, std::enable_if_t<std::is_same_v<decltype(T::location), Location>>>
++ {
++ static Location extract(const T &t) { return t.location; }
++ };
++
++ template <>
++ struct LocationExtractor<Binding, void>
++ {
++ static std::pair<Location, Location> extract(const Binding &binding)
++ {
++ return { binding.location, binding.valueLocation };
++ }
++ };
++
++ template <>
++ struct LocationExtractor<Alias, void>
++ {
++ static std::pair<Location, Location> extract(const Alias &alias)
++ {
++ return { alias.location(), alias.referenceLocation() };
++ }
++ };
++
++ template <>
++ struct LocationExtractor<Object, void>
++ {
++ static std::pair<Location, Location> extract(const Object &object)
++ {
++ return { object.location, object.locationOfIdProperty };
++ }
++ };
++
++ template <typename ElementT>
++ struct ComparisonTraits;
++
++ #define COMPARISON_TRAITS(Element) \
++ template <> \
++ struct ComparisonTraits<Element> \
++ { \
++ static constexpr ChangeType Changed = ChangeType::Element ## Changed; \
++ static constexpr ChangeType LocationChanged = ChangeType::None; \
++ static constexpr ChangeType Removed = ChangeType::Element ## Removed; \
++ static constexpr ChangeType Added = ChangeType::Element ## Added; \
++ };
++
++
++ #define COMPARISON_TRAITS_WITH_LOCATION(Element) \
++ template <> \
++ struct ComparisonTraits<Element> \
++ { \
++ static constexpr ChangeType Changed = ChangeType::Element ## Changed; \
++ static constexpr ChangeType LocationChanged = ChangeType::Element ## LocationChanged; \
++ static constexpr ChangeType Removed = ChangeType::Element ## Removed; \
++ static constexpr ChangeType Added = ChangeType::Element ## Added; \
++ };
++
++ COMPARISON_TRAITS_WITH_LOCATION(Object)
++ COMPARISON_TRAITS_WITH_LOCATION(Property)
++ COMPARISON_TRAITS_WITH_LOCATION(Alias)
++ COMPARISON_TRAITS_WITH_LOCATION(Enum)
++ COMPARISON_TRAITS_WITH_LOCATION(Signal)
++ COMPARISON_TRAITS_WITH_LOCATION(InlineComponent)
++ COMPARISON_TRAITS_WITH_LOCATION(Binding)
++ COMPARISON_TRAITS_WITH_LOCATION(Import)
++ COMPARISON_TRAITS_WITH_LOCATION(Function)
++
++ COMPARISON_TRAITS(RequiredPropertyExtraData)
++ COMPARISON_TRAITS(Constant)
++ COMPARISON_TRAITS(Lookup)
++ COMPARISON_TRAITS(RegExp)
++ COMPARISON_TRAITS(Class)
++ COMPARISON_TRAITS(TemplateObject)
++ COMPARISON_TRAITS(JSClass)
++ COMPARISON_TRAITS(Block)
++ COMPARISON_TRAITS(TranslationData)
++ COMPARISON_TRAITS(StringData)
++
++ template <typename AccessorFn>
++ struct IndexedElements
++ {
++ AccessorFn accessor;
++ quint32 count;
++ };
++
++ template <typename AccessorFn>
++ IndexedElements(AccessorFn, quint32) -> IndexedElements<AccessorFn>;
++
++ struct UnitDiffer
++ {
++ const Unit *const oldUnit;
++ const Unit *const newUnit;
++ QList<Change> changes;
++ int m_currentObjectIndex = -1;
++
++ template <typename ElementT, typename OldSource, typename NewSource, typename ContentEqFn>
++ void compareIndexedElements(OldSource oldSource, NewSource newSource, ContentEqFn contentEq)
++ {
++ using Traits = ComparisonTraits<ElementT>;
++ const auto &oldAccessor = oldSource.accessor;
++ const auto &newAccessor = newSource.accessor;
++ const quint32 oldCount = oldSource.count;
++ const quint32 newCount = newSource.count;
++ quint32 commonCount = qMin(oldCount, newCount);
++
++ // Compare elements at common positions
++ for (quint32 i = 0; i < commonCount; ++i) {
++ const ElementT &oldElem = oldAccessor(i);
++ const ElementT &newElem = newAccessor(i);
++
++ if (!contentEq(oldElem, newElem)) {
++ Change change;
++ change.objectIndex = m_currentObjectIndex;
++ change.index = i;
++ change.type = Traits::Changed;
++ change.data = extractData(newElem);
++ changes.append(change);
++ } else if (LocationExtractor<ElementT>::extract(oldElem)
++ != LocationExtractor<ElementT>::extract(newElem)) {
++ Change change;
++ change.objectIndex = m_currentObjectIndex;
++ change.index = i;
++ change.type = Traits::LocationChanged;
++ change.data = extractData(newElem);
++ changes.append(change);
++ }
++ }
++
++ // Emit Removed for extra elements in old
++ for (quint32 i = commonCount; i < oldCount; ++i) {
++ Change change;
++ change.type = Traits::Removed;
++ change.objectIndex = m_currentObjectIndex;
++ change.index = i;
++ changes.append(change);
++ }
++
++ // Emit Added for extra elements in new
++ for (quint32 i = commonCount; i < newCount; ++i) {
++ Change change;
++ change.type = Traits::Added;
++ change.objectIndex = m_currentObjectIndex;
++ change.index = i;
++ change.data = extractData(newAccessor(i));
++ changes.append(change);
++ }
++ }
++
++ bool stringsEqual(uint oldName, uint newName) const
++ {
++ Q_ASSERT(oldName < oldUnit->stringTableSize);
++ Q_ASSERT(newName < newUnit->stringTableSize);
++ return oldName == newName
++ && oldUnit->stringAtInternal(oldName) == newUnit->stringAtInternal(newName);
++ }
++
++ bool unitMetadataContentEqual() const
++ {
++ if (std::memcmp(oldUnit->magic, newUnit->magic, sizeof(oldUnit->magic)) != 0)
++ return false;
++
++ if (oldUnit->version != newUnit->version || oldUnit->reserved != newUnit->reserved
++ || oldUnit->sourceTimeStamp != newUnit->sourceTimeStamp
++ || oldUnit->unitSize != newUnit->unitSize) {
++ return false;
++ }
++
++ // sourceChecksum lives before md5Checksum and is therefore not covered by it.
++ if (std::memcmp(oldUnit->sourceChecksum, newUnit->sourceChecksum,
++ sizeof(oldUnit->sourceChecksum))
++ != 0) {
++ return false;
++ }
++
++ // If anything below the checksum has changed, the checksum itself has changed, too
++ return std::memcmp(oldUnit->md5Checksum, newUnit->md5Checksum, sizeof(oldUnit->md5Checksum))
++ == 0;
++ }
++
++ bool objectContentEqual(const Object &oldObj, const Object &newObj) const
++ {
++ // Keep in sync with the Object struct in qv4compileddata_p.h
++ static_assert(sizeof(Object) == 84, "Update objectContentEqual when Object layout changes");
++ if (oldObj.nNamedObjectsInComponent != newObj.nNamedObjectsInComponent)
++ return false;
++
++ const quint32_le *oldNamed = oldObj.namedObjectsInComponentTable();
++ const quint32_le *newNamed = newObj.namedObjectsInComponentTable();
++ for (quint32 i = 0; i < oldObj.nNamedObjectsInComponent; ++i) {
++ if (oldNamed[i] != newNamed[i])
++ return false;
++ }
++
++ if (oldObj.nFunctions != newObj.nFunctions)
++ return false;
++
++ const quint32_le *oldFuncs = oldObj.functionOffsetTable();
++ const quint32_le *newFuncs = newObj.functionOffsetTable();
++ for (quint32 i = 0; i < oldObj.nFunctions; ++i) {
++ if (oldFuncs[i] != newFuncs[i])
++ return false;
++ }
++
++ return stringsEqual(oldObj.inheritedTypeNameIndex, newObj.inheritedTypeNameIndex)
++ && stringsEqual(oldObj.idNameIndex, newObj.idNameIndex)
++ && oldObj.flags() == newObj.flags()
++ && oldObj.hasAliasAsDefaultProperty() == newObj.hasAliasAsDefaultProperty()
++ && oldObj.objectId() == newObj.objectId()
++ && oldObj.indexOfDefaultPropertyOrAlias == newObj.indexOfDefaultPropertyOrAlias;
++ }
++
++ bool propertyContentEqual(const Property &oldProp, const Property &newProp) const
++ {
++ // Keep in sync with the Property struct in qv4compileddata_p.h
++ static_assert(sizeof(Property) == 12, "Update propertyContentEqual when Property layout changes");
++ return stringsEqual(oldProp.nameIndex(), newProp.nameIndex())
++ && (oldProp.isCommonType() == newProp.isCommonType()
++ && (oldProp.isCommonType()
++ ? oldProp.commonTypeOrTypeNameIndex()
++ == newProp.commonTypeOrTypeNameIndex()
++ : stringsEqual(oldProp.typeNameIndex(), newProp.typeNameIndex())))
++ && oldProp.isReadOnly() == newProp.isReadOnly()
++ && oldProp.isRequired() == newProp.isRequired()
++ && oldProp.isList() == newProp.isList()
++ && oldProp.isVirtual() == newProp.isVirtual()
++ && oldProp.isOverride() == newProp.isOverride()
++ && oldProp.isFinal() == newProp.isFinal();
++ }
++
++ // In addition to structural equality, also compare the actual name strings: the integer
++ // nameIndex may be the same while the string at that index changed (property rename).
++ bool aliasContentEqual(const Alias &oldAlias, const Alias &newAlias) const
++ {
++ // Keep in sync with the Alias struct in qv4compileddata_p.h
++ static_assert(sizeof(Alias) == 20, "Update aliasContentEqual when Alias layout changes");
++ return stringsEqual(oldAlias.idIndex(), newAlias.idIndex())
++ && stringsEqual(oldAlias.nameIndex(), newAlias.nameIndex())
++ && stringsEqual(oldAlias.propertyNameIndex(), newAlias.propertyNameIndex())
++ && oldAlias.isReadOnly() == newAlias.isReadOnly();
++ }
++
++ bool enumContentEqual(const Enum &oldEnum, const Enum &newEnum) const
++ {
++ // Keep in sync with the Enum and EnumValue structs in qv4compileddata_p.h
++ static_assert(sizeof(Enum) == 12, "Update enumContentEqual when Enum layout changes");
++ static_assert(sizeof(EnumValue) == 8, "Update enumContentEqual when EnumValue layout changes");
++ if (!stringsEqual(oldEnum.nameIndex, newEnum.nameIndex)
++ || oldEnum.nEnumValues != newEnum.nEnumValues) {
++ return false;
++ }
++
++ for (quint32 i = 0; i < oldEnum.nEnumValues; ++i) {
++ const EnumValue *oldValue = oldEnum.enumValueAt(i);
++ const EnumValue *newValue = newEnum.enumValueAt(i);
++ if (oldValue->value != newValue->value
++ || !stringsEqual(oldValue->nameIndex, newValue->nameIndex)) {
++ return false;
++ }
++ }
++
++ return true;
++ }
++
++ bool signalContentEqual(const Signal &oldSig, const Signal &newSig) const
++ {
++ // Keep in sync with the Signal and Parameter structs in qv4compileddata_p.h
++ static_assert(sizeof(Signal) == 12, "Update signalContentEqual when Signal layout changes");
++ static_assert(sizeof(Parameter) == 8, "Update signalContentEqual when Parameter layout changes");
++ if (!stringsEqual(oldSig.nameIndex, newSig.nameIndex))
++ return false;
++ if (oldSig.nParameters != newSig.nParameters)
++ return false;
++ for (quint32 i = 0; i < oldSig.nParameters; ++i) {
++ const Parameter *oldP = oldSig.parameterAt(i);
++ const Parameter *newP = newSig.parameterAt(i);
++ if (!stringsEqual(oldP->nameIndex, newP->nameIndex)
++ || !parameterTypeContentEqual(oldP->type, newP->type)) {
++ return false;
++ }
++ }
++ return true;
++ }
++
++ bool bindingContentEqual(const Binding &oldBinding, const Binding &newBinding) const
++ {
++ // Keep in sync with the Binding and TranslationData structs in qv4compileddata_p.h
++ static_assert(sizeof(Binding) == 24, "Update bindingContentEqual when Binding layout changes");
++ static_assert(sizeof(TranslationData) == 16, "Update bindingContentEqual when TranslationData layout changes");
++ if (oldBinding.type() != newBinding.type() || oldBinding.flags() != newBinding.flags())
++ return false;
++
++ if (!stringsEqual(oldBinding.propertyNameIndex, newBinding.propertyNameIndex))
++ return false;
++
++ switch (oldBinding.type()) {
++ case Binding::Type_Invalid:
++ return true;
++ case Binding::Type_Boolean:
++ return oldBinding.valueAsBoolean() == newBinding.valueAsBoolean();
++ case Binding::Type_Number: {
++ const uint oldIdx = oldBinding.value.constantValueIndex;
++ const uint newIdx = newBinding.value.constantValueIndex;
++ Q_ASSERT(oldIdx < oldUnit->constantTableSize);
++ Q_ASSERT(newIdx < newUnit->constantTableSize);
++ return oldIdx == newIdx && oldUnit->constants()[oldIdx] == newUnit->constants()[newIdx];
++ }
++ case Binding::Type_String:
++ return stringsEqual(oldBinding.stringIndex, newBinding.stringIndex);
++ case Binding::Type_Null:
++ return true;
++ case Binding::Type_Translation:
++ case Binding::Type_TranslationById: {
++ const auto &oldTrans = oldUnit->translations()[oldBinding.value.translationDataIndex];
++ const auto &newTrans = newUnit->translations()[newBinding.value.translationDataIndex];
++
++ // contextIndex uses NoContextIndex as sentinel; compare by
++ // resolved string only when both are valid indices.
++ const bool oldHasCtx = oldTrans.contextIndex != TranslationData::NoContextIndex;
++ const bool newHasCtx = newTrans.contextIndex != TranslationData::NoContextIndex;
++
++ if (oldHasCtx != newHasCtx)
++ return false;
++
++ if (oldHasCtx && !stringsEqual(oldTrans.contextIndex, newTrans.contextIndex))
++ return false;
++
++ return stringsEqual(oldBinding.stringIndex, newBinding.stringIndex)
++ && stringsEqual(oldTrans.stringIndex, newTrans.stringIndex)
++ && stringsEqual(oldTrans.commentIndex, newTrans.commentIndex)
++ && oldTrans.number == newTrans.number;
++ }
++ case Binding::Type_Script:
++ return oldBinding.value.compiledScriptIndex == newBinding.value.compiledScriptIndex;
++ case Binding::Type_Object:
++ case Binding::Type_AttachedProperty:
++ case Binding::Type_GroupedProperty:
++ return oldBinding.value.objectIndex == newBinding.value.objectIndex
++ && objectContentEqual(
++ *oldUnit->qmlUnit()->objectAt(oldBinding.value.objectIndex),
++ *newUnit->qmlUnit()->objectAt(newBinding.value.objectIndex));
++ }
++
++ return false;
++ }
++
++ bool parameterTypeContentEqual(const ParameterType &oldType, const ParameterType &newType) const
++ {
++ // Keep in sync with the ParameterType struct in qv4compileddata_p.h
++ static_assert(sizeof(ParameterType) == 4, "Update parameterTypeContentEqual when ParameterType layout changes");
++ const bool indexIsCommonType = oldType.indexIsCommonType();
++ if (newType.indexIsCommonType() != indexIsCommonType
++ || oldType.isList() != newType.isList()) {
++ return false;
++ }
++
++ return indexIsCommonType
++ ? oldType.typeNameIndexOrCommonType() == newType.typeNameIndexOrCommonType()
++ : stringsEqual(oldType.typeNameIndexOrCommonType(),
++ newType.typeNameIndexOrCommonType());
++ }
++
++ bool functionContentEqual(const Function &oldFunc, const Function &newFunc) const
++ {
++ // Keep in sync with the Function struct in qv4compileddata_p.h
++ static_assert(sizeof(Function) == 56, "Update functionContentEqual when Function layout changes");
++ if (oldFunc.nestedFunctionIndex != newFunc.nestedFunctionIndex
++ || !stringsEqual(oldFunc.nameIndex, newFunc.nameIndex) || oldFunc.flags != newFunc.flags
++ || oldFunc.nFormals != newFunc.nFormals || oldFunc.codeSize != newFunc.codeSize
++ || !parameterTypeContentEqual(oldFunc.returnType, newFunc.returnType)) {
++ return false;
++ }
++
++ for (int i = 0, end = oldFunc.nFormals; i != end; ++i) {
++ const auto &oldFormal = oldFunc.formalsTable()[i];
++ const auto &newFormal = newFunc.formalsTable()[i];
++ if (!parameterTypeContentEqual(oldFormal.type, newFormal.type))
++ return false;
++ if (!stringsEqual(oldFormal.nameIndex, newFormal.nameIndex))
++ return false;
++ }
++
++ return std::memcmp(oldFunc.code(), newFunc.code(), oldFunc.codeSize) == 0;
++ }
++
++ bool translationContentEqual(const TranslationData &oldTrans,
++ const TranslationData &newTrans) const
++ {
++ // Keep in sync with the TranslationData struct in qv4compileddata_p.h
++ static_assert(sizeof(TranslationData) == 16, "Update translationContentEqual when TranslationData layout changes");
++ if (oldTrans.contextIndex != newTrans.contextIndex)
++ return false;
++ if (oldTrans.contextIndex != TranslationData::NoContextIndex
++ && !stringsEqual(oldTrans.contextIndex, newTrans.contextIndex)) {
++ return false;
++ }
++ return stringsEqual(oldTrans.stringIndex, newTrans.stringIndex)
++ && stringsEqual(oldTrans.commentIndex, newTrans.commentIndex)
++ && oldTrans.number == newTrans.number;
++ }
++
++ bool classContentEqual(const Class &oldCls, const Class &newCls) const
++ {
++ // Keep in sync with the Class and Method structs in qv4compileddata_p.h
++ static_assert(sizeof(Class) == 24, "Update classContentEqual when Class layout changes");
++ static_assert(sizeof(Method) == 12, "Update classContentEqual when Method layout changes");
++ if (!stringsEqual(oldCls.nameIndex, newCls.nameIndex)
++ || oldCls.scopeIndex != newCls.scopeIndex
++ || oldCls.constructorFunction != newCls.constructorFunction
++ || oldCls.nStaticMethods != newCls.nStaticMethods
++ || oldCls.nMethods != newCls.nMethods) {
++ return false;
++ }
++ const Method *oldMethods = oldCls.methodTable();
++ const Method *newMethods = newCls.methodTable();
++ for (quint32 i = 0, end = oldCls.nStaticMethods + oldCls.nMethods; i < end; ++i) {
++ if (!stringsEqual(oldMethods[i].name, newMethods[i].name)
++ || oldMethods[i].type != newMethods[i].type
++ || oldMethods[i].function != newMethods[i].function) {
++ return false;
++ }
++ }
++ return true;
++ }
++
++ bool templateObjectContentEqual(const TemplateObject &oldTO, const TemplateObject &newTO) const
++ {
++ // Keep in sync with the TemplateObject struct in qv4compileddata_p.h
++ static_assert(sizeof(TemplateObject) == 4, "Update templateObjectContentEqual when TemplateObject layout changes");
++ if (oldTO.size != newTO.size)
++ return false;
++ const quint32_le *oldStrings = reinterpret_cast<const quint32_le *>(&oldTO + 1);
++ const quint32_le *newStrings = reinterpret_cast<const quint32_le *>(&newTO + 1);
++ for (quint32 i = 0; i < 2u * oldTO.size; ++i) {
++ if (!stringsEqual(oldStrings[i], newStrings[i]))
++ return false;
++ }
++ return true;
++ }
++
++ bool jsClassContentEqual(const JSClass &oldJC, const JSClass &newJC) const
++ {
++ // Keep in sync with the JSClass and JSClassMember structs in qv4compileddata_p.h
++ static_assert(sizeof(JSClass) == 4, "Update jsClassContentEqual when JSClass layout changes");
++ static_assert(sizeof(JSClassMember) == 4, "Update jsClassContentEqual when JSClassMember layout changes");
++ if (oldJC.nMembers != newJC.nMembers)
++ return false;
++ const JSClassMember *oldMembers = reinterpret_cast<const JSClassMember *>(&oldJC + 1);
++ const JSClassMember *newMembers = reinterpret_cast<const JSClassMember *>(&newJC + 1);
++ for (quint32 i = 0; i < oldJC.nMembers; ++i) {
++ if (!stringsEqual(oldMembers[i].nameOffset(), newMembers[i].nameOffset())
++ || oldMembers[i].isAccessor() != newMembers[i].isAccessor()) {
++ return false;
++ }
++ }
++ return true;
++ }
++
++ bool blockContentEqual(const Block &oldBlock, const Block &newBlock) const
++ {
++ // Keep in sync with the Block struct in qv4compileddata_p.h
++ static_assert(sizeof(Block) == 12, "Update blockContentEqual when Block layout changes");
++ if (oldBlock.nLocals != newBlock.nLocals
++ || oldBlock.sizeOfLocalTemporalDeadZone != newBlock.sizeOfLocalTemporalDeadZone) {
++ return false;
++ }
++ for (quint32 i = 0; i < oldBlock.nLocals; ++i) {
++ if (!stringsEqual(oldBlock.localsTable()[i], newBlock.localsTable()[i]))
++ return false;
++ }
++ return true;
++ }
++
++ // Per-object comparison methods
++
++ void compareObjectProperties(const Object *oldObj, const Object *newObj)
++ {
++ const Property *oldProps = oldObj->propertyTable();
++ const Property *newProps = newObj->propertyTable();
++ compareIndexedElements<Property>(
++ IndexedElements{ [oldProps](quint32 i) { return oldProps[i]; },
++ oldObj->nProperties },
++ IndexedElements{ [newProps](quint32 i) { return newProps[i]; },
++ newObj->nProperties },
++ [this](const Property &a, const Property &b) {
++ return propertyContentEqual(a, b);
++ });
++ }
++
++ void compareObjectAliases(const Object *oldObj, const Object *newObj)
++ {
++ const Alias *oldAliases = oldObj->aliasesBegin();
++ const Alias *newAliases = newObj->aliasesBegin();
++ compareIndexedElements<Alias>(
++ IndexedElements{ [oldAliases](quint32 i) { return oldAliases[i]; },
++ oldObj->nAliases },
++ IndexedElements{ [newAliases](quint32 i) { return newAliases[i]; },
++ newObj->nAliases },
++ [this](const Alias &a, const Alias &b) { return aliasContentEqual(a, b); });
++ }
++
++ void compareObjectEnums(const Object *oldObj, const Object *newObj)
++ {
++ compareIndexedElements<Enum>(
++ IndexedElements{ [oldObj](quint32 i) -> const Enum & { return *oldObj->enumAt(i); },
++ oldObj->nEnums },
++ IndexedElements{ [newObj](quint32 i) -> const Enum & { return *newObj->enumAt(i); },
++ newObj->nEnums },
++ [this](const Enum &a, const Enum &b) { return enumContentEqual(a, b); });
++ }
++
++ void compareObjectSignals(const Object *oldObj, const Object *newObj)
++ {
++ compareIndexedElements<Signal>(
++ IndexedElements{
++ [oldObj](quint32 i) -> const Signal & { return *oldObj->signalAt(i); },
++ oldObj->nSignals },
++ IndexedElements{
++ [newObj](quint32 i) -> const Signal & { return *newObj->signalAt(i); },
++ newObj->nSignals },
++ [this](const Signal &a, const Signal &b) { return signalContentEqual(a, b); });
++ }
++
++ void compareObjectInlineComponents(const Object *oldObj, const Object *newObj)
++ {
++ const InlineComponent *oldICs = oldObj->inlineComponentTable();
++ const InlineComponent *newICs = newObj->inlineComponentTable();
++ compareIndexedElements<InlineComponent>(
++ IndexedElements{ [oldICs](quint32 i) { return oldICs[i]; },
++ oldObj->nInlineComponents },
++ IndexedElements{ [newICs](quint32 i) { return newICs[i]; },
++ newObj->nInlineComponents },
++ [this](const InlineComponent &a, const InlineComponent &b) {
++ return a.objectIndex == b.objectIndex && stringsEqual(a.nameIndex, b.nameIndex);
++ });
++ }
++
++ void compareObjectRequiredPropertyExtraData(const Object *oldObj, const Object *newObj)
++ {
++ const RequiredPropertyExtraData *oldRPED = oldObj->requiredPropertyExtraDataTable();
++ const RequiredPropertyExtraData *newRPED = newObj->requiredPropertyExtraDataTable();
++ compareIndexedElements<RequiredPropertyExtraData>(
++ IndexedElements{ [oldRPED](quint32 i) { return oldRPED[i]; },
++ oldObj->nRequiredPropertyExtraData },
++ IndexedElements{ [newRPED](quint32 i) { return newRPED[i]; },
++ newObj->nRequiredPropertyExtraData },
++ [this](const RequiredPropertyExtraData &a, const RequiredPropertyExtraData &b) {
++ return stringsEqual(a.nameIndex, b.nameIndex);
++ });
++ }
++
++ void compareObjectBindings(const Object *oldObj, const Object *newObj)
++ {
++ const Binding *oldBindings = oldObj->bindingTable();
++ const Binding *newBindings = newObj->bindingTable();
++ compareIndexedElements<Binding>(
++ IndexedElements{ [oldBindings](quint32 i) { return oldBindings[i]; },
++ oldObj->nBindings },
++ IndexedElements{ [newBindings](quint32 i) { return newBindings[i]; },
++ newObj->nBindings },
++ [this](const Binding &a, const Binding &b) { return bindingContentEqual(a, b); });
++ }
++
++ CompilationUnitDiff diff()
++ {
++ const QmlUnit *oldQml = oldUnit->qmlUnit();
++ const QmlUnit *newQml = newUnit->qmlUnit();
++
++ if (!oldQml || !newQml)
++ return CompilationUnitDiff();
++
++ // Check for unit metadata changes (source file, timestamp, checksum, etc.)
++ if (!unitMetadataContentEqual()) {
++ Change change;
++ change.type = ChangeType::UnitMetadataChanged;
++ change.data = extractData(*newUnit);
++ changes.append(change);
++ }
++
++ compareIndexedElements<Object>(
++ IndexedElements{
++ [oldQml](quint32 i) -> const Object & { return *oldQml->objectAt(i); },
++ oldQml->nObjects },
++ IndexedElements{
++ [newQml](quint32 i) -> const Object & { return *newQml->objectAt(i); },
++ newQml->nObjects },
++ [this](const Object &a, const Object &b) { return objectContentEqual(a, b); });
++
++ // Compare details of overlapping objects only
++ const quint32 commonCount = std::min(oldQml->nObjects, newQml->nObjects);
++ for (quint32 objectIndex = 0; objectIndex < commonCount; ++objectIndex) {
++ QScopedValueRollback guard(m_currentObjectIndex, static_cast<int>(objectIndex));
++ const Object *oldObj = oldQml->objectAt(objectIndex);
++ const Object *newObj = newQml->objectAt(objectIndex);
++
++ compareObjectProperties(oldObj, newObj);
++ compareObjectAliases(oldObj, newObj);
++ compareObjectEnums(oldObj, newObj);
++ compareObjectSignals(oldObj, newObj);
++ compareObjectInlineComponents(oldObj, newObj);
++ compareObjectRequiredPropertyExtraData(oldObj, newObj);
++ compareObjectBindings(oldObj, newObj);
++ }
++
++ compareIndexedElements<quint64_le>(
++ IndexedElements{ [this](quint32 i) { return oldUnit->constants()[i]; },
++ oldUnit->constantTableSize },
++ IndexedElements{ [this](quint32 i) { return newUnit->constants()[i]; },
++ newUnit->constantTableSize },
++ [](const quint64_le &a, const quint64_le &b) { return a == b; });
++
++ compareIndexedElements<QString>(
++ IndexedElements{ [this](quint32 i) { return oldUnit->stringAtInternal(i); },
++ oldUnit->stringTableSize },
++ IndexedElements{ [this](quint32 i) { return newUnit->stringAtInternal(i); },
++ newUnit->stringTableSize },
++ [](const QString &a, const QString &b) { return a == b; });
++
++ compareIndexedElements<Lookup>(
++ IndexedElements{ [this](quint32 i) { return oldUnit->lookupTable()[i]; },
++ oldUnit->lookupTableSize },
++ IndexedElements{ [this](quint32 i) { return newUnit->lookupTable()[i]; },
++ newUnit->lookupTableSize },
++ [this](const Lookup &a, const Lookup &b) {
++ return a.type() == b.type() && a.mode() == b.mode()
++ && stringsEqual(a.nameIndex(), b.nameIndex());
++ });
++
++ compareIndexedElements<Import>(
++ IndexedElements{ [oldQml](quint32 i) { return *oldQml->importAt(i); },
++ oldQml->nImports },
++ IndexedElements{ [newQml](quint32 i) { return *newQml->importAt(i); },
++ newQml->nImports },
++ [this](const Import &a, const Import &b) {
++ return a.type == b.type && stringsEqual(a.uriIndex, b.uriIndex)
++ && stringsEqual(a.qualifierIndex, b.qualifierIndex)
++ && a.version == b.version;
++ });
++
++ compareIndexedElements<Function>(IndexedElements{ [this](quint32 i) -> const Function & {
++ return *oldUnit->functionAt(i);
++ },
++ oldUnit->functionTableSize },
++ IndexedElements{ [this](quint32 i) -> const Function & {
++ return *newUnit->functionAt(i);
++ },
++ newUnit->functionTableSize },
++ [this](const Function &a, const Function &b) {
++ return functionContentEqual(a, b);
++ });
++
++ compareIndexedElements<TranslationData>(
++ IndexedElements{ [this](quint32 i) { return oldUnit->translations()[i]; },
++ oldUnit->translationTableSize },
++ IndexedElements{ [this](quint32 i) { return newUnit->translations()[i]; },
++ newUnit->translationTableSize },
++ [this](const TranslationData &a, const TranslationData &b) {
++ return translationContentEqual(a, b);
++ });
++
++ compareIndexedElements<RegExp>(
++ IndexedElements{
++ [this](quint32 i) -> const RegExp & { return *oldUnit->regexpAt(i); },
++ oldUnit->regexpTableSize },
++ IndexedElements{
++ [this](quint32 i) -> const RegExp & { return *newUnit->regexpAt(i); },
++ newUnit->regexpTableSize },
++ [this](const RegExp &a, const RegExp &b) {
++ return a.flags() == b.flags() && stringsEqual(a.stringIndex(), b.stringIndex());
++ });
++
++ compareIndexedElements<Class>(
++ IndexedElements{
++ [this](quint32 i) -> const Class & { return *oldUnit->classAt(i); },
++ oldUnit->classTableSize },
++ IndexedElements{
++ [this](quint32 i) -> const Class & { return *newUnit->classAt(i); },
++ newUnit->classTableSize },
++ [this](const Class &a, const Class &b) { return classContentEqual(a, b); });
++
++ compareIndexedElements<TemplateObject>(
++ IndexedElements{ [this](quint32 i) -> const TemplateObject & {
++ return *oldUnit->templateObjectAt(i);
++ },
++ oldUnit->templateObjectTableSize },
++ IndexedElements{ [this](quint32 i) -> const TemplateObject & {
++ return *newUnit->templateObjectAt(i);
++ },
++ newUnit->templateObjectTableSize },
++ [this](const TemplateObject &a, const TemplateObject &b) {
++ return templateObjectContentEqual(a, b);
++ });
++
++ {
++ auto jsClassFromUnit = [](const Unit *unit, quint32 idx) -> const JSClass & {
++ const quint32_le *offsetTable = reinterpret_cast<const quint32_le *>(
++ reinterpret_cast<const char *>(unit) + unit->offsetToJSClassTable);
++ return *reinterpret_cast<const JSClass *>(reinterpret_cast<const char *>(unit)
++ + offsetTable[idx]);
++ };
++ compareIndexedElements<JSClass>(
++ IndexedElements{ [this, jsClassFromUnit](quint32 i) -> const JSClass & {
++ return jsClassFromUnit(oldUnit, i);
++ },
++ oldUnit->jsClassTableSize },
++ IndexedElements{ [this, jsClassFromUnit](quint32 i) -> const JSClass & {
++ return jsClassFromUnit(newUnit, i);
++ },
++ newUnit->jsClassTableSize },
++ [this](const JSClass &a, const JSClass &b) {
++ return jsClassContentEqual(a, b);
++ });
++ }
++
++ compareIndexedElements<Block>(
++ IndexedElements{
++ [this](quint32 i) -> const Block & { return *oldUnit->blockAt(i); },
++ oldUnit->blockTableSize },
++ IndexedElements{
++ [this](quint32 i) -> const Block & { return *newUnit->blockAt(i); },
++ newUnit->blockTableSize },
++ [this](const Block &a, const Block &b) { return blockContentEqual(a, b); });
++
++ return CompilationUnitDiff{ std::move(changes), true };
++ }
++ };
++
++ // NB: AddObject and RemoveObject are mutually exclusive since all objects are
++ // in a global order per compilation unit. The number of objects can either
++ // grow or shrink, but not both. Likewise AddBinding and RemoveBinding, but
++ // per object. Before adding bindings, all the objects need to be present.
++ // It's a good idea to remove stale bindings before they can cause any
++ // trouble. Therefore, we do that first, before changing or adding bindings.
++ enum Severity : quint8 {
++ Replace,
++ Rebuild,
++ AddObject,
++ RemoveBinding,
++ ChangeBinding,
++ AddBinding,
++ RemoveObject,
++ Ignore,
++ };
++
++ static Severity classifyChange(const Change &change)
++ {
++ switch (change.type) {
++ case QV4::CompiledData::ChangeType::UnitMetadataChanged:
++ case QV4::CompiledData::ChangeType::ObjectChanged:
++ case QV4::CompiledData::ChangeType::ImportAdded:
++ case QV4::CompiledData::ChangeType::ImportRemoved:
++ case QV4::CompiledData::ChangeType::ImportChanged:
++ case QV4::CompiledData::ChangeType::InlineComponentAdded:
++ case QV4::CompiledData::ChangeType::InlineComponentRemoved:
++ case QV4::CompiledData::ChangeType::InlineComponentChanged:
++ case QV4::CompiledData::ChangeType::Unknown:
++ return Replace;
++ case QV4::CompiledData::ChangeType::PropertyAdded:
++ case QV4::CompiledData::ChangeType::PropertyRemoved:
++ case QV4::CompiledData::ChangeType::PropertyChanged:
++ case QV4::CompiledData::ChangeType::AliasAdded:
++ case QV4::CompiledData::ChangeType::AliasRemoved:
++ case QV4::CompiledData::ChangeType::AliasChanged:
++ case QV4::CompiledData::ChangeType::FunctionAdded:
++ case QV4::CompiledData::ChangeType::FunctionRemoved:
++ case QV4::CompiledData::ChangeType::FunctionChanged:
++ case QV4::CompiledData::ChangeType::EnumAdded:
++ case QV4::CompiledData::ChangeType::EnumRemoved:
++ case QV4::CompiledData::ChangeType::EnumChanged:
++ case QV4::CompiledData::ChangeType::SignalAdded:
++ case QV4::CompiledData::ChangeType::SignalRemoved:
++ case QV4::CompiledData::ChangeType::SignalChanged:
++ case QV4::CompiledData::ChangeType::RequiredPropertyExtraDataAdded:
++ case QV4::CompiledData::ChangeType::RequiredPropertyExtraDataRemoved:
++ case QV4::CompiledData::ChangeType::RequiredPropertyExtraDataChanged:
++ return Rebuild;
++ case QV4::CompiledData::ChangeType::ObjectAdded:
++ return AddObject;
++ case QV4::CompiledData::ChangeType::BindingRemoved:
++ return RemoveBinding;
++ case QV4::CompiledData::ChangeType::BindingChanged:
++ return ChangeBinding;
++ case QV4::CompiledData::ChangeType::BindingAdded:
++ return AddBinding;
++ case QV4::CompiledData::ChangeType::ObjectRemoved:
++ return RemoveObject;
++ case QV4::CompiledData::ChangeType::AliasLocationChanged:
++ case QV4::CompiledData::ChangeType::BindingLocationChanged:
++ case QV4::CompiledData::ChangeType::EnumLocationChanged:
++ case QV4::CompiledData::ChangeType::FunctionLocationChanged:
++ case QV4::CompiledData::ChangeType::ImportLocationChanged:
++ case QV4::CompiledData::ChangeType::InlineComponentLocationChanged:
++ case QV4::CompiledData::ChangeType::ObjectLocationChanged:
++ case QV4::CompiledData::ChangeType::PropertyLocationChanged:
++ case QV4::CompiledData::ChangeType::SignalLocationChanged:
++ return Ignore;
++ case QV4::CompiledData::ChangeType::ConstantAdded:
++ case QV4::CompiledData::ChangeType::ConstantRemoved:
++ case QV4::CompiledData::ChangeType::ConstantChanged:
++ case QV4::CompiledData::ChangeType::StringDataAdded:
++ case QV4::CompiledData::ChangeType::StringDataRemoved:
++ case QV4::CompiledData::ChangeType::StringDataChanged:
++ case QV4::CompiledData::ChangeType::LookupAdded:
++ case QV4::CompiledData::ChangeType::LookupRemoved:
++ case QV4::CompiledData::ChangeType::LookupChanged:
++ case QV4::CompiledData::ChangeType::RegExpAdded:
++ case QV4::CompiledData::ChangeType::RegExpRemoved:
++ case QV4::CompiledData::ChangeType::RegExpChanged:
++ case QV4::CompiledData::ChangeType::ClassAdded:
++ case QV4::CompiledData::ChangeType::ClassRemoved:
++ case QV4::CompiledData::ChangeType::ClassChanged:
++ case QV4::CompiledData::ChangeType::TemplateObjectAdded:
++ case QV4::CompiledData::ChangeType::TemplateObjectRemoved:
++ case QV4::CompiledData::ChangeType::TemplateObjectChanged:
++ case QV4::CompiledData::ChangeType::JSClassAdded:
++ case QV4::CompiledData::ChangeType::JSClassRemoved:
++ case QV4::CompiledData::ChangeType::JSClassChanged:
++ case QV4::CompiledData::ChangeType::BlockAdded:
++ case QV4::CompiledData::ChangeType::BlockRemoved:
++ case QV4::CompiledData::ChangeType::BlockChanged:
++ case QV4::CompiledData::ChangeType::TranslationDataAdded:
++ case QV4::CompiledData::ChangeType::TranslationDataRemoved:
++ case QV4::CompiledData::ChangeType::TranslationDataChanged:
++ case QV4::CompiledData::ChangeType::None:
++ break;
++ }
++ return Ignore;
++ }
++
++ static void sortChanges(QSpan<Change> changes)
++ {
++ std::stable_sort(changes.begin(), changes.end(), [](const Change &a, const Change &b) {
++ return quint8(classifyChange(a)) < quint8(classifyChange(b));
++ });
++ }
++
++ CompilationUnitDiff diffCompilationUnits(const Unit *oldUnit, const Unit *newUnit)
++ {
++ auto diff = UnitDiffer{ oldUnit, newUnit, {} }.diff();
++
++ // Sort the changes so that they are easy to apply.
++ // We want the most severe changes first.
++ sortChanges(diff.changes);
++
++ return diff;
++ }
++
++ } // namespace QV4::CompiledData
++
++ QT_END_NAMESPACE