Make "on" syntax mandatory for value sources and interceptors

Where you would have written

   x: NumberAnimation {}
   y: Behavior {}

you now must write

   NumberAnimation on x {}
   Behavior on y {}

This change also makes the parser more strict with respect to multiple
assignments to a single property - they're no longer allowed.  For example
this

   x: 10
   x: 11

is now an error.

1 files changed, 124 insertions, 85 deletions

diff --git a/src/declarative/qml/qdeclarativecompiler.cpp b/src/declarative/qml/qdeclarativecompiler.cpp
index 5da207d..a9809c0 100644
--- a/src/declarative/qml/qdeclarativecompiler.cpp
+++ b/src/declarative/qml/qdeclarativecompiler.cpp
@@ -718,6 +718,7 @@ bool QDeclarativeCompiler::buildObject(Object *obj, const BindingContext &ctxt)
     BindingContext objCtxt(obj);
 
     // Create the synthesized meta object, ignoring aliases
+    COMPILE_CHECK(checkDynamicMeta(obj)); 
     COMPILE_CHECK(mergeDynamicMetaProperties(obj));
     COMPILE_CHECK(buildDynamicMeta(obj, IgnoreAliases));
 
@@ -1623,6 +1624,10 @@ void QDeclarativeCompiler::genPropertyAssignment(QDeclarativeParser::Property *p
     for (int ii = 0; ii < prop->values.count(); ++ii) {
         QDeclarativeParser::Value *v = prop->values.at(ii);
 
+        Q_ASSERT(v->type == Value::CreatedObject ||
+                 v->type == Value::PropertyBinding ||
+                 v->type == Value::Literal);
+
         if (v->type == Value::CreatedObject) {
 
             genObject(v->object);
@@ -1652,7 +1657,27 @@ void QDeclarativeCompiler::genPropertyAssignment(QDeclarativeParser::Property *p
                 output->bytecode << store;
 
             }
-        } else if (v->type == Value::ValueSource) {
+        } else if (v->type == Value::PropertyBinding) {
+
+            genBindingAssignment(v, prop, obj, valueTypeProperty);
+
+        } else if (v->type == Value::Literal) {
+
+            QMetaProperty mp = obj->metaObject()->property(prop->index);
+            genLiteralAssignment(mp, v);
+
+        }
+
+    }
+
+    for (int ii = 0; ii < prop->onValues.count(); ++ii) {
+
+        QDeclarativeParser::Value *v = prop->onValues.at(ii);
+
+        Q_ASSERT(v->type == Value::ValueSource ||
+                 v->type == Value::ValueInterceptor);
+
+        if (v->type == Value::ValueSource) {
             genObject(v->object);
 
             QDeclarativeInstruction store;
@@ -1685,16 +1710,6 @@ void QDeclarativeCompiler::genPropertyAssignment(QDeclarativeParser::Property *p
             QDeclarativeType *valueType = toQmlType(v->object);
             store.assignValueInterceptor.castValue = valueType->propertyValueInterceptorCast();
             output->bytecode << store;
-
-        } else if (v->type == Value::PropertyBinding) {
-
-            genBindingAssignment(v, prop, obj, valueTypeProperty);
-
-        } else if (v->type == Value::Literal) {
-
-            QMetaProperty mp = obj->metaObject()->property(prop->index);
-            genLiteralAssignment(mp, v);
-
         }
 
     }
@@ -1793,8 +1808,8 @@ bool QDeclarativeCompiler::buildAttachedProperty(QDeclarativeParser::Property *p
 // }
 // font is a nested property.  pointSize and family are not.
 bool QDeclarativeCompiler::buildGroupedProperty(QDeclarativeParser::Property *prop,
-                                       QDeclarativeParser::Object *obj,
-                                       const BindingContext &ctxt)
+                                                QDeclarativeParser::Object *obj,
+                                                const BindingContext &ctxt)
 {
     Q_ASSERT(prop->type != 0);
     Q_ASSERT(prop->index != -1);
@@ -1829,9 +1844,9 @@ bool QDeclarativeCompiler::buildGroupedProperty(QDeclarativeParser::Property *pr
 }
 
 bool QDeclarativeCompiler::buildValueTypeProperty(QObject *type,
-                                         QDeclarativeParser::Object *obj,
-                                         QDeclarativeParser::Object *baseObj,
-                                         const BindingContext &ctxt)
+                                                  QDeclarativeParser::Object *obj,
+                                                  QDeclarativeParser::Object *baseObj,
+                                                  const BindingContext &ctxt)
 {
     if (obj->defaultProperty)
         COMPILE_EXCEPTION(obj, QCoreApplication::translate("QDeclarativeCompiler","Invalid property use"));
@@ -1848,37 +1863,36 @@ bool QDeclarativeCompiler::buildValueTypeProperty(QObject *type,
         if (prop->value)
             COMPILE_EXCEPTION(prop, QCoreApplication::translate("QDeclarativeCompiler","Property assignment expected"));
 
-        if (prop->values.count() != 1)
+        if (prop->values.count() > 1) {
             COMPILE_EXCEPTION(prop, QCoreApplication::translate("QDeclarativeCompiler","Single property assignment expected"));
+        } else if (prop->values.count()) {
+            Value *value = prop->values.at(0);
 
-        Value *value = prop->values.at(0);
-
-        if (value->object) {
-            bool isPropertyValue = output->types.at(value->object->type).type->propertyValueSourceCast() != -1;
-            bool isPropertyInterceptor = output->types.at(value->object->type).type->propertyValueInterceptorCast() != -1;
-            if (!isPropertyValue && !isPropertyInterceptor) {
+            if (value->object) {
                 COMPILE_EXCEPTION(prop, QCoreApplication::translate("QDeclarativeCompiler","Unexpected object assignment"));
-            } else {
-                COMPILE_CHECK(buildObject(value->object, ctxt));
-
-                if (isPropertyInterceptor && baseObj->synthdata.isEmpty())
-                    buildDynamicMeta(baseObj, ForceCreation);
-                value->type = isPropertyValue ? Value::ValueSource : Value::ValueInterceptor;
+            } else if (value->value.isScript()) {
+                // ### Check for writability
+                BindingReference reference;
+                reference.expression = value->value;
+                reference.property = prop;
+                reference.value = value;
+                reference.bindingContext = ctxt;
+                reference.bindingContext.owner++;
+                addBindingReference(reference);
+                value->type = Value::PropertyBinding;
+            } else  {
+                COMPILE_CHECK(testLiteralAssignment(p, value));
+                value->type = Value::Literal;
             }
-        } else if (value->value.isScript()) {
-            // ### Check for writability
-            BindingReference reference;
-            reference.expression = value->value;
-            reference.property = prop;
-            reference.value = value;
-            reference.bindingContext = ctxt;
-            reference.bindingContext.owner++;
-            addBindingReference(reference);
-            value->type = Value::PropertyBinding;
-        } else  {
-            COMPILE_CHECK(testLiteralAssignment(p, value));
-            value->type = Value::Literal;
         }
+
+        for (int ii = 0; ii < prop->onValues.count(); ++ii) {
+            Value *v = prop->onValues.at(ii);
+            Q_ASSERT(v->object);
+
+            COMPILE_CHECK(buildPropertyOnAssignment(prop, obj, baseObj, v, ctxt)); 
+        }
+
         obj->addValueProperty(prop);
     }
 
@@ -1886,13 +1900,11 @@ bool QDeclarativeCompiler::buildValueTypeProperty(QObject *type,
 }
 
 // Build assignments to QML lists.  QML lists are properties of type
-// QList<T *> * and QDeclarativeList<T *> *.
-//
-// QList<T *> * types can accept a list of objects, or a single binding
-// QDeclarativeList<T *> * types can accept a list of objects
+// QDeclarativeListProperty<T>.  List properties can accept a list of 
+// objects, or a single binding.
 bool QDeclarativeCompiler::buildListProperty(QDeclarativeParser::Property *prop,
-                                    QDeclarativeParser::Object *obj,
-                                    const BindingContext &ctxt)
+                                             QDeclarativeParser::Object *obj,
+                                             const BindingContext &ctxt)
 {
     Q_ASSERT(QDeclarativeEnginePrivate::get(engine)->isList(prop->type));
 
@@ -1950,20 +1962,6 @@ bool QDeclarativeCompiler::buildScriptStringProperty(QDeclarativeParser::Propert
 }
 
 // Compile regular property assignments of the form "property: <value>"
-//
-// ### The following problems exist
-//
-// There is no distinction between how "lists" of values are specified.  This
-//    Item {
-//        children: Item {}
-//        children: Item {}
-//    }
-// is identical to
-//    Item {
-//        children: [ Item {}, Item {} ]
-//    }
-//
-// We allow assignming multiple values to single value properties
 bool QDeclarativeCompiler::buildPropertyAssignment(QDeclarativeParser::Property *prop,
                                           QDeclarativeParser::Object *obj,
                                           const BindingContext &ctxt)
@@ -1983,14 +1981,21 @@ bool QDeclarativeCompiler::buildPropertyAssignment(QDeclarativeParser::Property
         }
     }
 
+    for (int ii = 0; ii < prop->onValues.count(); ++ii) {
+        Value *v = prop->onValues.at(ii);
+
+        Q_ASSERT(v->object);
+        COMPILE_CHECK(buildPropertyOnAssignment(prop, obj, obj, v, ctxt));
+    }
+
     return true;
 }
 
 // Compile assigning a single object instance to a regular property
 bool QDeclarativeCompiler::buildPropertyObjectAssignment(QDeclarativeParser::Property *prop,
-                                                QDeclarativeParser::Object *obj,
-                                                QDeclarativeParser::Value *v,
-                                                const BindingContext &ctxt)
+                                                         QDeclarativeParser::Object *obj,
+                                                         QDeclarativeParser::Value *v,
+                                                         const BindingContext &ctxt)
 {
     Q_ASSERT(prop->index != -1);
     Q_ASSERT(v->object->type != -1);
@@ -2019,15 +2024,6 @@ bool QDeclarativeCompiler::buildPropertyObjectAssignment(QDeclarativeParser::Pro
         v->object->metatype = output->types.at(v->object->type).metaObject();
         Q_ASSERT(v->object->metaObject());
 
-        // Will be true if the assigned type inherits QDeclarativePropertyValueSource
-        bool isPropertyValue = false;
-        // Will be true if the assigned type inherits QDeclarativePropertyValueInterceptor
-        bool isPropertyInterceptor = false;
-        if (QDeclarativeType *valueType = toQmlType(v->object)) {
-            isPropertyValue = valueType->propertyValueSourceCast() != -1;
-            isPropertyInterceptor = valueType->propertyValueInterceptorCast() != -1;
-        }
-
         // We want to raw metaObject here as the raw metaobject is the
         // actual property type before we applied any extensions that might
         // effect the properties on the type, but don't effect assignability
@@ -2063,13 +2059,6 @@ bool QDeclarativeCompiler::buildPropertyObjectAssignment(QDeclarativeParser::Pro
             component->getDefaultProperty()->addValue(componentValue);
             v->object = component;
             COMPILE_CHECK(buildPropertyObjectAssignment(prop, obj, v, ctxt));
-        } else if (isPropertyValue || isPropertyInterceptor) {
-            // Assign as a property value source
-            COMPILE_CHECK(buildObject(v->object, ctxt));
-
-            if (isPropertyInterceptor && prop->parent->synthdata.isEmpty())
-                   buildDynamicMeta(prop->parent, ForceCreation);
-            v->type = isPropertyValue ? Value::ValueSource : Value::ValueInterceptor;
         } else {
             COMPILE_EXCEPTION(v->object, QCoreApplication::translate("QDeclarativeCompiler","Cannot assign object to property"));
         }
@@ -2078,6 +2067,55 @@ bool QDeclarativeCompiler::buildPropertyObjectAssignment(QDeclarativeParser::Pro
     return true;
 }
 
+// Compile assigning a single object instance to a regular property using the "on" syntax.
+//
+// For example:
+//     Item {
+//         NumberAnimation on x { }
+//     }
+bool QDeclarativeCompiler::buildPropertyOnAssignment(QDeclarativeParser::Property *prop,
+                                                     QDeclarativeParser::Object *obj,
+                                                     QDeclarativeParser::Object *baseObj,
+                                                     QDeclarativeParser::Value *v,
+                                                     const BindingContext &ctxt)
+{
+    Q_ASSERT(prop->index != -1);
+    Q_ASSERT(v->object->type != -1);
+
+    if (!obj->metaObject()->property(prop->index).isWritable())
+        COMPILE_EXCEPTION(v, QCoreApplication::translate("QDeclarativeCompiler","Invalid property assignment: \"%1\" is a read-only property").arg(QString::fromUtf8(prop->name)));
+
+
+    // Normally buildObject() will set this up, but we need the static
+    // meta object earlier to test for assignability.  It doesn't matter
+    // that there may still be outstanding synthesized meta object changes
+    // on this type, as they are not relevant for assignability testing
+    v->object->metatype = output->types.at(v->object->type).metaObject();
+    Q_ASSERT(v->object->metaObject());
+
+    // Will be true if the assigned type inherits QDeclarativePropertyValueSource
+    bool isPropertyValue = false;
+    // Will be true if the assigned type inherits QDeclarativePropertyValueInterceptor
+    bool isPropertyInterceptor = false;
+    if (QDeclarativeType *valueType = toQmlType(v->object)) {
+        isPropertyValue = valueType->propertyValueSourceCast() != -1;
+        isPropertyInterceptor = valueType->propertyValueInterceptorCast() != -1;
+    }
+
+    if (isPropertyValue || isPropertyInterceptor) {
+        // Assign as a property value source
+        COMPILE_CHECK(buildObject(v->object, ctxt));
+
+        if (isPropertyInterceptor && prop->parent->synthdata.isEmpty())
+            buildDynamicMeta(baseObj, ForceCreation);
+        v->type = isPropertyValue ? Value::ValueSource : Value::ValueInterceptor;
+    } else {
+        COMPILE_EXCEPTION(v, QCoreApplication::translate("QDeclarativeCompiler","\"%1\" cannot operate on \"%2\"").arg(v->object->typeName.constData()).arg(prop->name.constData()));
+    }
+
+    return true;
+}
+
 // Compile assigning a literal or binding to a regular property
 bool QDeclarativeCompiler::buildPropertyLiteralAssignment(QDeclarativeParser::Property *prop,
                                                  QDeclarativeParser::Object *obj,
@@ -2203,10 +2241,13 @@ bool QDeclarativeCompiler::mergeDynamicMetaProperties(QDeclarativeParser::Object
             continue;
 
         Property *property = 0;
-        if (p.isDefaultProperty)
+        if (p.isDefaultProperty) {
             property = obj->getDefaultProperty();
-        else
+        } else {
             property = obj->getProperty(p.name);
+            if (!property->values.isEmpty()) 
+                COMPILE_EXCEPTION(property, QCoreApplication::translate("QDeclarativeCompiler","Property value set multiple times"));
+        }
 
         if (property->value)
             COMPILE_EXCEPTION(property, QCoreApplication::translate("QDeclarativeCompiler","Invalid property nesting"));
@@ -2233,8 +2274,6 @@ bool QDeclarativeCompiler::buildDynamicMeta(QDeclarativeParser::Object *obj, Dyn
         obj->dynamicSlots.isEmpty())
         return true;
 
-    COMPILE_CHECK(checkDynamicMeta(obj));
-
     QByteArray dynamicData(sizeof(QDeclarativeVMEMetaData), (char)0);
 
     QByteArray newClassName = obj->metatype->className();