Order and manner of property binding evaluations in QML - c++

Question

From what I understand, when properties are used in binding expressions, their NOTIFY signals are connected to signal the reevaluation of the expression every time a property value is changed.
So consider this trivial example:
Rectangle {
width: 200
height: width - 100
Text {
text: "value is " + (parent.width + parent.height)
}
}
In it the height property is bound to the width property, and the text property is bound to both.
In this example, it is not clear what is the order of operation. I mean if width changes, it will emit to reevaluate both of the expressions which reference it. But width will also change height which itself will trigger evaluation of text as well.
Is the text property therefore evaluated twice? Once when width changes, and once again when width changes height? Or maybe QML has some mechanism of optimizing that behavior away, like for example the notification signals do not trigger actual reevaluation but only mark the expressions "dirty" and they are reevaluated on the next event loop iteration, when all signaling has been propagated? And even so, how would the engine know to update height before updating text to avoid the double reevaluation of the latter? Or maybe the connection is direct rather than queued, and some more complex mechanism is used to figure out the order of reevaluation? Or maybe there is nothing of the sort and text might actually reevaluate twice if it just so happens to be the arbitrary order?
I really need to understand how this works, because I have a project where I modify multiple properties of multiple QML objects on the C++ side in a imperative manner which are bound on the QML side and I get very inconsistent and erratic behavior, so I definitely need to take into consideration the way those work.

Answer 1

Yes. it looks that you are right and text will be update twice. The simple example:
Rectangle {
id: testRect
width: 200
height: width - 100
Text {
text: "value is " + (parent.width + parent.height)
onTextChanged: {
console.log("text was changed (" + parent.width + "," + parent.height + ")");
}
}
MouseArea {
anchors.fill: parent
onClicked: {
testRect.width = 300
}
}
}
output:
qml: text was changed (200,100)
qml: text was changed (300,100)
qml: text was changed (300,200)
I guess it's simple behavior and updates relevant property when changes some properties this item based on.
Qt docs advices to avoid such situation - However, if a binding is overly complex - such as involving multiple lines, or imperative loops - it could indicate that the binding is being used for more than describing property relationships. Complex bindings can reduce code performance, readability, and maintainability. It may be a good idea to redesign components that have complex bindings, or at least factor the binding out into a separate function.