1 files changed, 196 insertions, 109 deletions

diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index 1249e1b6c8..10d16a8a12 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -42,8 +42,8 @@
 #include "qqml.h"
 #include "qqmlcontext.h"
 #include "qqmlinfo.h"
-#include "qqmlcompiler_p.h"
 #include "qqmldata_p.h"
+#include "qqmlaccessors_p.h"
 #include <private/qqmlprofiler_p.h>
 #include <private/qqmlexpression_p.h>
 #include <private/qqmlscriptstring_p.h>
@@ -57,27 +57,28 @@
 
 QT_BEGIN_NAMESPACE
 
-QQmlBinding::QQmlBinding(const QString &str, QObject *obj, QQmlContext *ctxt)
-    : QQmlJavaScriptExpression(),
-      QQmlAbstractBinding()
+QQmlBinding *QQmlBinding::create(const QQmlPropertyData *property, const QString &str, QObject *obj, QQmlContext *ctxt)
 {
-    setNotifyOnValueChanged(true);
-    QQmlJavaScriptExpression::setContext(QQmlContextData::get(ctxt));
-    setScopeObject(obj);
+    QQmlBinding *b = newBinding(property);
+    b->setNotifyOnValueChanged(true);
+    b->QQmlJavaScriptExpression::setContext(QQmlContextData::get(ctxt));
+    b->setScopeObject(obj);
 
-    createQmlBinding(context(), obj, str, QString(), 0);
+    b->createQmlBinding(b->context(), obj, str, QString(), 0);
+
+    return b;
 }
 
-QQmlBinding::QQmlBinding(const QQmlScriptString &script, QObject *obj, QQmlContext *ctxt)
-    : QQmlJavaScriptExpression(),
-      QQmlAbstractBinding()
+QQmlBinding *QQmlBinding::create(const QQmlPropertyData *property, const QQmlScriptString &script, QObject *obj, QQmlContext *ctxt)
 {
+    QQmlBinding *b = newBinding(property);
+
     if (ctxt && !ctxt->isValid())
-        return;
+        return b;
 
     const QQmlScriptStringPrivate *scriptPrivate = script.d.data();
     if (!ctxt && (!scriptPrivate->context || !scriptPrivate->context->isValid()))
-        return;
+        return b;
 
     QString url;
     QV4::Function *runtimeFunction = 0;
@@ -90,53 +91,61 @@ QQmlBinding::QQmlBinding(const QQmlScriptString &script, QObject *obj, QQmlConte
             runtimeFunction = ctxtdata->typeCompilationUnit->runtimeFunctions.at(scriptPrivate->bindingId);
     }
 
-    setNotifyOnValueChanged(true);
-    QQmlJavaScriptExpression::setContext(QQmlContextData::get(ctxt ? ctxt : scriptPrivate->context));
-    setScopeObject(obj ? obj : scriptPrivate->scope);
+    b->setNotifyOnValueChanged(true);
+    b->QQmlJavaScriptExpression::setContext(QQmlContextData::get(ctxt ? ctxt : scriptPrivate->context));
+    b->setScopeObject(obj ? obj : scriptPrivate->scope);
 
-    QV4::ExecutionEngine *v4 = QQmlEnginePrivate::get(context()->engine)->v4engine();
+    QV4::ExecutionEngine *v4 = QQmlEnginePrivate::get(b->context()->engine)->v4engine();
     if (runtimeFunction) {
-        m_function.set(v4, QV4::FunctionObject::createQmlFunction(ctxtdata, scopeObject(), runtimeFunction));
+        b->m_function.set(v4, QV4::FunctionObject::createQmlFunction(ctxtdata, b->scopeObject(), runtimeFunction));
     } else {
         QString code = scriptPrivate->script;
-        createQmlBinding(context(), scopeObject(), code, url, scriptPrivate->lineNumber);
+        b->createQmlBinding(b->context(), b->scopeObject(), code, url, scriptPrivate->lineNumber);
     }
+
+    return b;
 }
 
-QQmlBinding::QQmlBinding(const QString &str, QObject *obj, QQmlContextData *ctxt)
-    : QQmlJavaScriptExpression(),
-      QQmlAbstractBinding()
+QQmlBinding *QQmlBinding::create(const QQmlPropertyData *property, const QString &str, QObject *obj, QQmlContextData *ctxt)
 {
-    setNotifyOnValueChanged(true);
-    QQmlJavaScriptExpression::setContext(ctxt);
-    setScopeObject(obj);
+    QQmlBinding *b = newBinding(property);
+
+    b->setNotifyOnValueChanged(true);
+    b->QQmlJavaScriptExpression::setContext(ctxt);
+    b->setScopeObject(obj);
 
-    createQmlBinding(ctxt, obj, str, QString(), 0);
+    b->createQmlBinding(ctxt, obj, str, QString(), 0);
+
+    return b;
 }
 
-QQmlBinding::QQmlBinding(const QString &str, QObject *obj,
-                         QQmlContextData *ctxt,
-                         const QString &url, quint16 lineNumber, quint16 columnNumber)
-    : QQmlJavaScriptExpression(),
-      QQmlAbstractBinding()
+QQmlBinding *QQmlBinding::create(const QQmlPropertyData *property, const QString &str, QObject *obj,
+                                 QQmlContextData *ctxt, const QString &url, quint16 lineNumber,
+                                 quint16 columnNumber)
 {
+    QQmlBinding *b = newBinding(property);
+
     Q_UNUSED(columnNumber);
-    setNotifyOnValueChanged(true);
-    QQmlJavaScriptExpression::setContext(ctxt);
-    setScopeObject(obj);
+    b->setNotifyOnValueChanged(true);
+    b->QQmlJavaScriptExpression::setContext(ctxt);
+    b->setScopeObject(obj);
 
-    createQmlBinding(ctxt, obj, str, url, lineNumber);
+    b->createQmlBinding(ctxt, obj, str, url, lineNumber);
+
+    return b;
 }
 
-QQmlBinding::QQmlBinding(const QV4::Value &functionPtr, QObject *obj, QQmlContextData *ctxt)
-    : QQmlJavaScriptExpression(),
-      QQmlAbstractBinding()
+QQmlBinding *QQmlBinding::create(const QQmlPropertyData *property, const QV4::Value &functionPtr, QObject *obj, QQmlContextData *ctxt)
 {
-    setNotifyOnValueChanged(true);
-    QQmlJavaScriptExpression::setContext(ctxt);
-    setScopeObject(obj);
+    QQmlBinding *b = newBinding(property);
+
+    b->setNotifyOnValueChanged(true);
+    b->QQmlJavaScriptExpression::setContext(ctxt);
+    b->setScopeObject(obj);
 
-    m_function.set(functionPtr.as<QV4::Object>()->engine(), functionPtr);
+    b->m_function.set(functionPtr.as<QV4::Object>()->engine(), functionPtr);
+
+    return b;
 }
 
 QQmlBinding::~QQmlBinding()
@@ -148,7 +157,7 @@ void QQmlBinding::setNotifyOnValueChanged(bool v)
     QQmlJavaScriptExpression::setNotifyOnValueChanged(v);
 }
 
-void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
+void QQmlBinding::update(QQmlPropertyData::WriteFlags flags)
 {
     if (!enabledFlag() || !context() || !context()->isValid())
         return;
@@ -157,44 +166,73 @@ void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
     if (QQmlData::wasDeleted(targetObject()))
         return;
 
+    // Check for a binding update loop
+    if (Q_UNLIKELY(updatingFlag())) {
+        QQmlProperty p = QQmlPropertyPrivate::restore(targetObject(), getPropertyData(), 0);
+        QQmlAbstractBinding::printBindingLoopError(p);
+        return;
+    }
+    setUpdatingFlag(true);
+
+    DeleteWatcher watcher(this);
+
     QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context()->engine);
     QV4::Scope scope(ep->v4engine());
     QV4::ScopedFunctionObject f(scope, m_function.value());
     Q_ASSERT(f);
 
-    if (updatingFlag()) {
-        QQmlProperty p = QQmlPropertyPrivate::restore(targetObject(), getPropertyData(), 0);
-        QQmlAbstractBinding::printBindingLoopError(p);
-        return;
-    }
+    if (canUseAccessor())
+        flags.setFlag(QQmlPropertyData::BypassInterceptor);
 
     QQmlBindingProfiler prof(ep->profiler, this, f);
-    setUpdatingFlag(true);
-
-    QQmlJavaScriptExpression::DeleteWatcher watcher(this);
+    doUpdate(this, watcher, flags, scope, f);
 
-    QQmlPropertyData pd = getPropertyData();
+    if (!watcher.wasDeleted())
+        setUpdatingFlag(false);
+}
 
-    if (pd.propType == qMetaTypeId<QQmlBinding *>()) {
+// QQmlBindingBinding is for target properties which are of type "binding" (instead of, say, int or
+// double). The reason for being is that GenericBinding::fastWrite needs a compile-time constant
+// expression for the switch for the compiler to generate the optimal code, but
+// qMetaTypeId<QQmlBinding *>() needs to be used for the ID. So QQmlBinding::newBinding uses that
+// to instantiate this class.
+class QQmlBindingBinding: public QQmlBinding
+{
+protected:
+    void doUpdate(QQmlBinding *binding, const DeleteWatcher &,
+                  QQmlPropertyData::WriteFlags flags, QV4::Scope &,
+                  const QV4::ScopedFunctionObject &) Q_DECL_OVERRIDE Q_DECL_FINAL
+    {
+        QQmlPropertyData pd = getPropertyData();
 
         int idx = pd.coreIndex;
         Q_ASSERT(idx != -1);
 
-        QQmlBinding *t = this;
         int status = -1;
-        void *a[] = { &t, 0, &status, &flags };
+        void *a[] = { &binding, 0, &status, &flags };
         QMetaObject::metacall(*m_target, QMetaObject::WriteProperty, idx, a);
+    }
+};
 
-    } else {
+template<int StaticPropType>
+class GenericBinding: public QQmlBinding
+{
+protected:
+    void doUpdate(QQmlBinding *binding, const DeleteWatcher &watcher,
+                  QQmlPropertyData::WriteFlags flags, QV4::Scope &scope,
+                  const QV4::ScopedFunctionObject &f) Q_DECL_OVERRIDE Q_DECL_FINAL
+    {
+        auto ep = QQmlEnginePrivate::get(scope.engine);
         ep->referenceScarceResources();
 
         bool isUndefined = false;
 
-        QV4::ScopedValue result(scope, QQmlJavaScriptExpression::evaluate(&isUndefined));
+        QV4::ScopedCallData callData(scope);
+        binding->QQmlJavaScriptExpression::evaluate(callData, &isUndefined, scope);
 
         bool error = false;
         if (!watcher.wasDeleted() && isAddedToObject() && !hasError())
-            error = !write(pd, result, isUndefined, flags);
+            error = !write(scope.result, isUndefined, flags);
 
         if (!watcher.wasDeleted()) {
 
@@ -214,59 +252,65 @@ void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
         ep->dereferenceScarceResources();
     }
 
-    if (!watcher.wasDeleted())
-        setUpdatingFlag(false);
-}
-
-// Returns true if successful, false if an error description was set on expression
-bool QQmlBinding::write(const QQmlPropertyData &core,
-                       const QV4::Value &result, bool isUndefined,
-                       QQmlPropertyPrivate::WriteFlags flags)
-{
-    Q_ASSERT(m_target.data());
-    Q_ASSERT(core.coreIndex != -1);
-
-#define QUICK_STORE(cpptype, conversion) \
-        { \
-            cpptype o = (conversion); \
-            int status = -1; \
-            void *argv[] = { &o, 0, &status, &flags }; \
-            QMetaObject::metacall(m_target.data(), QMetaObject::WriteProperty, core.coreIndex, argv); \
-            return true; \
-        } \
-
-
-    if (Q_LIKELY(!isUndefined && !core.isValueTypeVirtual())) {
-        switch (core.propType) {
-        case QMetaType::Int:
-            if (result.isInteger())
-                QUICK_STORE(int, result.integerValue())
-            else if (result.isNumber())
-                QUICK_STORE(int, result.doubleValue())
-            break;
-        case QMetaType::Double:
-            if (result.isNumber())
-                QUICK_STORE(double, result.asDouble())
-            break;
-        case QMetaType::Float:
-            if (result.isNumber())
-                QUICK_STORE(float, result.asDouble())
-            break;
-        case QMetaType::QString:
-            if (result.isString())
-                QUICK_STORE(QString, result.toQStringNoThrow())
-            break;
-        default:
-            if (const QV4::QQmlValueTypeWrapper *vtw = result.as<const QV4::QQmlValueTypeWrapper>()) {
-                if (vtw->d()->valueType->typeId == core.propType) {
-                    return vtw->write(m_target.data(), core.coreIndex);
+    // Returns true if successful, false if an error description was set on expression
+    Q_ALWAYS_INLINE bool write(const QV4::Value &result, bool isUndefined,
+                               QQmlPropertyData::WriteFlags flags)
+    {
+        QQmlPropertyData pd = getPropertyData();
+        int propertyType = StaticPropType; // If the binding is specialized to a type, the if and switch below will be constant-folded.
+        if (propertyType == QMetaType::UnknownType)
+            propertyType = pd.propType;
+        Q_ASSERT(targetObject());
+
+        if (Q_LIKELY(!isUndefined && !pd.isValueTypeVirtual())) {
+            switch (propertyType) {
+            case QMetaType::Bool:
+                if (result.isBoolean())
+                    return doStore<bool>(result.booleanValue(), pd, flags);
+                else
+                    return doStore<bool>(result.toBoolean(), pd, flags);
+            case QMetaType::Int:
+                if (result.isInteger())
+                    return doStore<int>(result.integerValue(), pd, flags);
+                else if (result.isNumber())
+                    return doStore<int>(result.doubleValue(), pd, flags);
+                break;
+            case QMetaType::Double:
+                if (result.isNumber())
+                    return doStore<double>(result.asDouble(), pd, flags);
+                break;
+            case QMetaType::Float:
+                if (result.isNumber())
+                    return doStore<float>(result.asDouble(), pd, flags);
+                break;
+            case QMetaType::QString:
+                if (result.isString())
+                    return doStore<QString>(result.toQStringNoThrow(), pd, flags);
+                break;
+            default:
+                if (const QV4::QQmlValueTypeWrapper *vtw = result.as<const QV4::QQmlValueTypeWrapper>()) {
+                    if (vtw->d()->valueType->typeId == pd.propType) {
+                        return vtw->write(m_target.data(), pd.coreIndex);
+                    }
                 }
+                break;
             }
-            break;
         }
+
+        return slowWrite(pd, result, isUndefined, flags);
+    }
+
+    template <typename T>
+    Q_ALWAYS_INLINE bool doStore(T value, const QQmlPropertyData &pd, QQmlPropertyData::WriteFlags flags) const
+    {
+        void *o = &value;
+        return pd.writeProperty(targetObject(), o, flags);
     }
-#undef QUICK_STORE
+};
 
+Q_NEVER_INLINE bool QQmlBinding::slowWrite(const QQmlPropertyData &core, const QV4::Value &result,
+                                           bool isUndefined, QQmlPropertyData::WriteFlags flags)
+{
     QQmlEngine *engine = context()->engine;
     QV8Engine *v8engine = QQmlEnginePrivate::getV8Engine(engine);
 
@@ -378,11 +422,12 @@ QVariant QQmlBinding::evaluate()
     bool isUndefined = false;
 
     QV4::Scope scope(ep->v4engine());
-    QV4::ScopedValue result(scope, QQmlJavaScriptExpression::evaluate(&isUndefined));
+    QV4::ScopedCallData callData(scope);
+    QQmlJavaScriptExpression::evaluate(callData, &isUndefined, scope);
 
     ep->dereferenceScarceResources();
 
-    return scope.engine->toVariant(result, qMetaTypeId<QList<QObject*> >());
+    return scope.engine->toVariant(scope.result, qMetaTypeId<QList<QObject*> >());
 }
 
 QString QQmlBinding::expressionIdentifier()
@@ -409,11 +454,18 @@ void QQmlBinding::refresh()
     update();
 }
 
-void QQmlBinding::setEnabled(bool e, QQmlPropertyPrivate::WriteFlags flags)
+void QQmlBinding::setEnabled(bool e, QQmlPropertyData::WriteFlags flags)
 {
     setEnabledFlag(e);
     setNotifyOnValueChanged(e);
 
+    m_nextBinding.setFlag2(); // Always use accessors, only not when:
+    if (auto interceptorMetaObject = QQmlInterceptorMetaObject::get(targetObject())) {
+        int coreIndex = getPropertyCoreIndex();
+        if (coreIndex == -1 || interceptorMetaObject->intercepts(coreIndex))
+            m_nextBinding.clearFlag2();
+    }
+
     if (e)
         update(flags);
 }
@@ -509,4 +561,39 @@ QQmlPropertyData QQmlBinding::getPropertyData() const
     return d;
 }
 
+Q_ALWAYS_INLINE int QQmlBinding::getPropertyCoreIndex() const
+{
+    int coreIndex;
+    int valueTypeIndex = QQmlPropertyData::decodeValueTypePropertyIndex(m_targetIndex, &coreIndex);
+    if (valueTypeIndex != -1) {
+        return -1;
+    } else {
+        return coreIndex;
+    }
+}
+
+QQmlBinding *QQmlBinding::newBinding(const QQmlPropertyData *property)
+{
+    const int type = (property && property->isFullyResolved()) ? property->propType : QMetaType::UnknownType;
+
+    if (type == qMetaTypeId<QQmlBinding *>()) {
+        return new QQmlBindingBinding;
+    }
+
+    switch (type) {
+    case QMetaType::Bool:
+        return new GenericBinding<QMetaType::Bool>;
+    case QMetaType::Int:
+        return new GenericBinding<QMetaType::Int>;
+    case QMetaType::Double:
+        return new GenericBinding<QMetaType::Double>;
+    case QMetaType::Float:
+        return new GenericBinding<QMetaType::Float>;
+    case QMetaType::QString:
+        return new GenericBinding<QMetaType::QString>;
+    default:
+        return new GenericBinding<QMetaType::UnknownType>;
+    }
+}
+
 QT_END_NAMESPACE