Only generate a warning when assigning null to incompatible properties

Such code used to work before and we should not break it without a
proper deprecation procedure.

Change-Id: I049caf6ae5cc06aa796b19eda858612935b8d674
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

6 files changed, 90 insertions, 63 deletions

diff --git a/src/qml/compiler/qqmlpropertyvalidator.cpp b/src/qml/compiler/qqmlpropertyvalidator.cpp
index a6b57841a8..4e8f57c2cf 100644
--- a/src/qml/compiler/qqmlpropertyvalidator.cpp
+++ b/src/qml/compiler/qqmlpropertyvalidator.cpp
@@ -350,30 +350,45 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         return noError;
     }
 
+    auto warnOrError = [&](const QString &error) {
+        if (binding->type == QV4::CompiledData::Binding::Type_Null) {
+            QQmlError warning;
+            warning.setUrl(compilationUnit->url());
+            warning.setLine(binding->valueLocation.line);
+            warning.setColumn(binding->valueLocation.column);
+            warning.setDescription(error + tr(" - Assigning null to incompatible properties in QML "
+                                              "is deprecated. This will become a compile error in "
+                                              "future versions of Qt."));
+            enginePrivate->warning(warning);
+            return noError;
+        }
+        return QQmlCompileError(binding->valueLocation, error);
+    };
+
     switch (property->propType()) {
     case QMetaType::QVariant:
     break;
     case QVariant::String: {
         if (!binding->evaluatesToString()) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: string expected"));
+            return warnOrError(tr("Invalid property assignment: string expected"));
         }
     }
     break;
     case QVariant::StringList: {
         if (!binding->evaluatesToString()) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: string or string list expected"));
+            return warnOrError(tr("Invalid property assignment: string or string list expected"));
         }
     }
     break;
     case QVariant::ByteArray: {
         if (binding->type != QV4::CompiledData::Binding::Type_String) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: byte array expected"));
+            return warnOrError(tr("Invalid property assignment: byte array expected"));
         }
     }
     break;
     case QVariant::Url: {
         if (binding->type != QV4::CompiledData::Binding::Type_String) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: url expected"));
+            return warnOrError(tr("Invalid property assignment: url expected"));
         }
     }
     break;
@@ -383,7 +398,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
             if (double(uint(d)) == d)
                 return noError;
         }
-        return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: unsigned int expected"));
+        return warnOrError(tr("Invalid property assignment: unsigned int expected"));
     }
     break;
     case QVariant::Int: {
@@ -392,18 +407,18 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
             if (double(int(d)) == d)
                 return noError;
         }
-        return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: int expected"));
+        return warnOrError(tr("Invalid property assignment: int expected"));
     }
     break;
     case QMetaType::Float: {
         if (binding->type != QV4::CompiledData::Binding::Type_Number) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: number expected"));
+            return warnOrError(tr("Invalid property assignment: number expected"));
         }
     }
     break;
     case QVariant::Double: {
         if (binding->type != QV4::CompiledData::Binding::Type_Number) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: number expected"));
+            return warnOrError(tr("Invalid property assignment: number expected"));
         }
     }
     break;
@@ -411,7 +426,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::rgbaFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: color expected"));
+            return warnOrError(tr("Invalid property assignment: color expected"));
         }
     }
     break;
@@ -420,7 +435,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::dateFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: date expected"));
+            return warnOrError(tr("Invalid property assignment: date expected"));
         }
     }
     break;
@@ -428,7 +443,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::timeFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: time expected"));
+            return warnOrError(tr("Invalid property assignment: time expected"));
         }
     }
     break;
@@ -436,7 +451,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::dateTimeFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: datetime expected"));
+            return warnOrError(tr("Invalid property assignment: datetime expected"));
         }
     }
     break;
@@ -445,7 +460,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::pointFFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: point expected"));
+            return warnOrError(tr("Invalid property assignment: point expected"));
         }
     }
     break;
@@ -453,7 +468,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::pointFFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: point expected"));
+            return warnOrError(tr("Invalid property assignment: point expected"));
         }
     }
     break;
@@ -461,7 +476,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::sizeFFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: size expected"));
+            return warnOrError(tr("Invalid property assignment: size expected"));
         }
     }
     break;
@@ -469,7 +484,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::sizeFFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: size expected"));
+            return warnOrError(tr("Invalid property assignment: size expected"));
         }
     }
     break;
@@ -477,7 +492,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::rectFFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: rect expected"));
+            return warnOrError(tr("Invalid property assignment: rect expected"));
         }
     }
     break;
@@ -485,13 +500,13 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         bool ok = false;
         QQmlStringConverters::rectFFromString(binding->valueAsString(compilationUnit.data()), &ok);
         if (!ok) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: point expected"));
+            return warnOrError(tr("Invalid property assignment: point expected"));
         }
     }
     break;
     case QVariant::Bool: {
         if (binding->type != QV4::CompiledData::Binding::Type_Boolean) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: boolean expected"));
+            return warnOrError(tr("Invalid property assignment: boolean expected"));
         }
     }
     break;
@@ -501,7 +516,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
             float yp;
         } vec;
         if (!QQmlStringConverters::createFromString(QMetaType::QVector2D, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec))) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: 2D vector expected"));
+            return warnOrError(tr("Invalid property assignment: 2D vector expected"));
         }
     }
     break;
@@ -512,7 +527,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
             float zy;
         } vec;
         if (!QQmlStringConverters::createFromString(QMetaType::QVector3D, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec))) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: 3D vector expected"));
+            return warnOrError(tr("Invalid property assignment: 3D vector expected"));
         }
     }
     break;
@@ -524,7 +539,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
             float wp;
         } vec;
         if (!QQmlStringConverters::createFromString(QMetaType::QVector4D, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec))) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: 4D vector expected"));
+            return warnOrError(tr("Invalid property assignment: 4D vector expected"));
         }
     }
     break;
@@ -536,17 +551,17 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
             float zp;
         } vec;
         if (!QQmlStringConverters::createFromString(QMetaType::QQuaternion, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec))) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: quaternion expected"));
+            return warnOrError(tr("Invalid property assignment: quaternion expected"));
         }
     }
     break;
     case QVariant::RegExp:
-        return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: regular expression expected; use /pattern/ syntax"));
+        return warnOrError(tr("Invalid property assignment: regular expression expected; use /pattern/ syntax"));
     default: {
         // generate single literal value assignment to a list property if required
         if (property->propType() == qMetaTypeId<QList<qreal> >()) {
             if (binding->type != QV4::CompiledData::Binding::Type_Number) {
-                return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: number or array of numbers expected"));
+                return warnOrError(tr("Invalid property assignment: number or array of numbers expected"));
             }
             break;
         } else if (property->propType() == qMetaTypeId<QList<int> >()) {
@@ -557,21 +572,21 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
                     ok = false;
             }
             if (!ok)
-                return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: int or array of ints expected"));
+                return warnOrError(tr("Invalid property assignment: int or array of ints expected"));
             break;
         } else if (property->propType() == qMetaTypeId<QList<bool> >()) {
             if (binding->type != QV4::CompiledData::Binding::Type_Boolean) {
-                return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: bool or array of bools expected"));
+                return warnOrError(tr("Invalid property assignment: bool or array of bools expected"));
             }
             break;
         } else if (property->propType() == qMetaTypeId<QList<QUrl> >()) {
             if (binding->type != QV4::CompiledData::Binding::Type_String) {
-                return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: url or array of urls expected"));
+                return warnOrError(tr("Invalid property assignment: url or array of urls expected"));
             }
             break;
         } else if (property->propType() == qMetaTypeId<QList<QString> >()) {
             if (!binding->evaluatesToString()) {
-                return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: string or array of strings expected"));
+                return warnOrError(tr("Invalid property assignment: string or array of strings expected"));
             }
             break;
         } else if (property->propType() == qMetaTypeId<QJSValue>()) {
@@ -586,7 +601,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         // otherwise, try a custom type assignment
         QQmlMetaType::StringConverter converter = QQmlMetaType::customStringConverter(property->propType());
         if (!converter) {
-            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: unsupported type \"%1\"").arg(QString::fromLatin1(QMetaType::typeName(property->propType()))));
+            return warnOrError(tr("Invalid property assignment: unsupported type \"%1\"").arg(QString::fromLatin1(QMetaType::typeName(property->propType()))));
         }
     }
     break;
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index ca5498d06c..c36b3ed386 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -379,6 +379,18 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         }
     }
 
+    auto assertOrNull = [&](bool ok)
+    {
+        Q_ASSERT(ok || binding->type == QV4::CompiledData::Binding::Type_Null);
+        Q_UNUSED(ok);
+    };
+
+    auto assertType = [&](QV4::CompiledData::Binding::ValueType type)
+    {
+        Q_ASSERT(binding->type == type || binding->type == QV4::CompiledData::Binding::Type_Null);
+        Q_UNUSED(type);
+    };
+
     if (property->isQObject()) {
         if (binding->type == QV4::CompiledData::Binding::Type_Null) {
             QObject *value = nullptr;
@@ -436,25 +448,25 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     break;
     case QVariant::String: {
-        Q_ASSERT(binding->evaluatesToString());
+        assertOrNull(binding->evaluatesToString());
         QString value = binding->valueAsString(compilationUnit.data());
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::StringList: {
-        Q_ASSERT(binding->evaluatesToString());
+        assertOrNull(binding->evaluatesToString());
         QStringList value(binding->valueAsString(compilationUnit.data()));
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::ByteArray: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_String);
+        assertType(QV4::CompiledData::Binding::Type_String);
         QByteArray value(binding->valueAsString(compilationUnit.data()).toUtf8());
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::Url: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_String);
+        assertType(QV4::CompiledData::Binding::Type_String);
         QString string = binding->valueAsString(compilationUnit.data());
         // Encoded dir-separators defeat QUrl processing - decode them first
         string.replace(QLatin1String("%2f"), QLatin1String("/"), Qt::CaseInsensitive);
@@ -466,7 +478,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     break;
     case QVariant::UInt: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Number);
+        assertType(QV4::CompiledData::Binding::Type_Number);
         double d = binding->valueAsNumber(compilationUnit->constants);
         uint value = uint(d);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
@@ -474,7 +486,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     break;
     case QVariant::Int: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Number);
+        assertType(QV4::CompiledData::Binding::Type_Number);
         double d = binding->valueAsNumber(compilationUnit->constants);
         int value = int(d);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
@@ -482,13 +494,13 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     }
     break;
     case QMetaType::Float: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Number);
+        assertType(QV4::CompiledData::Binding::Type_Number);
         float value = float(binding->valueAsNumber(compilationUnit->constants));
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::Double: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Number);
+        assertType(QV4::CompiledData::Binding::Type_Number);
         double value = binding->valueAsNumber(compilationUnit->constants);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
@@ -496,7 +508,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     case QVariant::Color: {
         bool ok = false;
         uint colorValue = QQmlStringConverters::rgbaFromString(binding->valueAsString(compilationUnit.data()), &ok);
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         struct { void *data[4]; } buffer;
         if (QQml_valueTypeProvider()->storeValueType(property->propType(), &colorValue, &buffer, sizeof(buffer))) {
             property->writeProperty(_qobject, &buffer, propertyWriteFlags);
@@ -507,14 +519,14 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     case QVariant::Date: {
         bool ok = false;
         QDate value = QQmlStringConverters::dateFromString(binding->valueAsString(compilationUnit.data()), &ok);
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::Time: {
         bool ok = false;
         QTime value = QQmlStringConverters::timeFromString(binding->valueAsString(compilationUnit.data()), &ok);
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
@@ -527,7 +539,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
             const int msecsSinceStartOfDay = value.time().msecsSinceStartOfDay();
             value = QDateTime(QDate::fromJulianDay(date), QTime::fromMSecsSinceStartOfDay(msecsSinceStartOfDay));
         }
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
@@ -535,47 +547,47 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
     case QVariant::Point: {
         bool ok = false;
         QPoint value = QQmlStringConverters::pointFFromString(binding->valueAsString(compilationUnit.data()), &ok).toPoint();
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::PointF: {
         bool ok = false;
         QPointF value = QQmlStringConverters::pointFFromString(binding->valueAsString(compilationUnit.data()), &ok);
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::Size: {
         bool ok = false;
         QSize value = QQmlStringConverters::sizeFFromString(binding->valueAsString(compilationUnit.data()), &ok).toSize();
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::SizeF: {
         bool ok = false;
         QSizeF value = QQmlStringConverters::sizeFFromString(binding->valueAsString(compilationUnit.data()), &ok);
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::Rect: {
         bool ok = false;
         QRect value = QQmlStringConverters::rectFFromString(binding->valueAsString(compilationUnit.data()), &ok).toRect();
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::RectF: {
         bool ok = false;
         QRectF value = QQmlStringConverters::rectFFromString(binding->valueAsString(compilationUnit.data()), &ok);
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
     case QVariant::Bool: {
-        Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Boolean);
+        assertType(QV4::CompiledData::Binding::Type_Boolean);
         bool value = binding->valueAsBoolean();
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
@@ -586,7 +598,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
             float yp;
         } vec;
         bool ok = QQmlStringConverters::createFromString(QMetaType::QVector2D, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec));
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         Q_UNUSED(ok);
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
@@ -598,7 +610,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
             float zy;
         } vec;
         bool ok = QQmlStringConverters::createFromString(QMetaType::QVector3D, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec));
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         Q_UNUSED(ok);
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
@@ -611,7 +623,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
             float wp;
         } vec;
         bool ok = QQmlStringConverters::createFromString(QMetaType::QVector4D, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec));
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         Q_UNUSED(ok);
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
@@ -624,37 +636,37 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
             float zp;
         } vec;
         bool ok = QQmlStringConverters::createFromString(QMetaType::QQuaternion, binding->valueAsString(compilationUnit.data()), &vec, sizeof(vec));
-        Q_ASSERT(ok);
+        assertOrNull(ok);
         Q_UNUSED(ok);
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
     break;
     case QVariant::RegExp:
-        Q_ASSERT(!"not possible");
+        assertOrNull(!"not possible");
         break;
     default: {
         // generate single literal value assignment to a list property if required
         if (property->propType() == qMetaTypeId<QList<qreal> >()) {
-            Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Number);
+            assertType(QV4::CompiledData::Binding::Type_Number);
             QList<qreal> value;
             value.append(binding->valueAsNumber(compilationUnit->constants));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
         } else if (property->propType() == qMetaTypeId<QList<int> >()) {
-            Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Number);
+            assertType(QV4::CompiledData::Binding::Type_Number);
             double n = binding->valueAsNumber(compilationUnit->constants);
             QList<int> value;
             value.append(int(n));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
         } else if (property->propType() == qMetaTypeId<QList<bool> >()) {
-            Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_Boolean);
+            assertType(QV4::CompiledData::Binding::Type_Boolean);
             QList<bool> value;
             value.append(binding->valueAsBoolean());
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
         } else if (property->propType() == qMetaTypeId<QList<QUrl> >()) {
-            Q_ASSERT(binding->type == QV4::CompiledData::Binding::Type_String);
+            assertType(QV4::CompiledData::Binding::Type_String);
             QString urlString = binding->valueAsString(compilationUnit.data());
             QUrl u = urlString.isEmpty() ? QUrl()
                                          : compilationUnit->finalUrl().resolved(QUrl(urlString));
@@ -663,7 +675,7 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
             property->writeProperty(_qobject, &value, propertyWriteFlags);
             break;
         } else if (property->propType() == qMetaTypeId<QList<QString> >()) {
-            Q_ASSERT(binding->evaluatesToString());
+            assertOrNull(binding->evaluatesToString());
             QList<QString> value;
             value.append(binding->valueAsString(compilationUnit.data()));
             property->writeProperty(_qobject, &value, propertyWriteFlags);
diff --git a/tests/auto/qml/qqmlcomponent/data/createObjectWithScript.qml b/tests/auto/qml/qqmlcomponent/data/createObjectWithScript.qml
index c5ebed612c..989b295cb5 100644
--- a/tests/auto/qml/qqmlcomponent/data/createObjectWithScript.qml
+++ b/tests/auto/qml/qqmlcomponent/data/createObjectWithScript.qml
@@ -18,7 +18,7 @@ Item{
         id: b
         Item{
             property bool testBool: false
-            property int testInt: { return null; }
+            property int testInt: null
             property QtObject testObject: null
         }
     }
diff --git a/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.1.qml b/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.1.qml
index ac5622f9fb..acd5463a3c 100644
--- a/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.1.qml
+++ b/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.1.qml
@@ -10,7 +10,7 @@ Item {
         }
     }
 
-    property bool expectNull: { return null; }
+    property bool expectNull: null
 
     function setExpectNull(b) {
         success = false;
diff --git a/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.2.qml b/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.2.qml
index 3c18739c32..ed0e0d10f0 100644
--- a/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.2.qml
+++ b/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.2.qml
@@ -10,7 +10,7 @@ Item {
         }
     }
 
-    property bool expectNull: { return null; }
+    property bool expectNull: null
 
     function setExpectNull(b) {
         success = false;
diff --git a/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.3.qml b/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.3.qml
index e2e560199f..f5e94ba715 100644
--- a/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.3.qml
+++ b/tests/auto/qml/qqmllanguage/data/objectDeletionNotify.3.qml
@@ -10,7 +10,7 @@ Item {
         }
     }
 
-    property bool expectNull: { return null; }
+    property bool expectNull: null
 
     function setExpectNull(b) {
         success = false;