Merge remote-tracking branch 'origin/5.7' into dev

Conflicts:
	src/quick/items/qquickshadereffect.cpp
5.7 had a bug-fix in code dev has replaced wholesale.

	src/quick/items/qquickwindow.cpp
	src/quick/items/qquickwindow_p.h
One side changed a method's signature; the other side renamed a method
declared adjacent to it and changed some code using it, moving some
from the public class to its private partner.

	tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp
One side added a blank line before a comment the other re-wrote.
Kept the re-write, killed the stray blank.

	.qmake.conf
Ignore 5.7's change to MODULE_VERSION.

	src/qml/compiler/qqmltypecompiler.cpp
	src/qml/compiler/qqmlpropertyvalidator.cpp
5.7 changed code in the former that dev moved to the latter.
Reflect 5.7's changes there, adapted to dev's form.

	src/qml/qml/qqmlobjectcreator.cpp
One side added new QVariant types; the other changed how it handled
each type of QVariant (without git seeing any conflict); adapted the
new stanzas to work the same as the transformed ones.

	tests/manual/v4/test262
dev had a broken sha1 for it; so used 5.7's 9741ac4655808ac46c127e3d1d8ba3d27ada618e

Change-Id: I1fbe2255b97d6ef405cdd1d0cea7fab8dc351d6f

19 files changed, 318 insertions, 75 deletions

diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp
index 7d96f11768..f59ccc551e 100644
--- a/src/imports/localstorage/plugin.cpp
+++ b/src/imports/localstorage/plugin.cpp
@@ -149,7 +149,12 @@ public:
 
 using namespace QV4;
 
+QT_WARNING_PUSH
+#if (Q_CC_GNU >= 600)
+QT_WARNING_DISABLE_GCC("-Wtautological-compare")
+#endif
 DEFINE_OBJECT_VTABLE(QV4::QQmlSqlDatabaseWrapper);
+QT_WARNING_POP
 
 
 
diff --git a/src/qml/compiler/qqmlpropertyvalidator.cpp b/src/qml/compiler/qqmlpropertyvalidator.cpp
index 9ea52e240d..c644330e97 100644
--- a/src/qml/compiler/qqmlpropertyvalidator.cpp
+++ b/src/qml/compiler/qqmlpropertyvalidator.cpp
@@ -492,6 +492,16 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         }
     }
     break;
+    case QVariant::Vector2D: {
+        struct {
+            float xp;
+            float yp;
+        } vec;
+        if (!QQmlStringConverters::createFromString(QMetaType::QVector2D, binding->valueAsString(qmlUnit), &vec, sizeof(vec))) {
+            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: 2D vector expected"));
+        }
+    }
+    break;
     case QVariant::Vector3D: {
         struct {
             float xp;
@@ -515,6 +525,18 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
         }
     }
     break;
+    case QVariant::Quaternion: {
+        struct {
+            float wp;
+            float xp;
+            float yp;
+            float zp;
+        } vec;
+        if (!QQmlStringConverters::createFromString(QMetaType::QQuaternion, binding->valueAsString(qmlUnit), &vec, sizeof(vec))) {
+            return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: quaternion expected"));
+        }
+    }
+    break;
     case QVariant::RegExp:
         return QQmlCompileError(binding->valueLocation, tr("Invalid property assignment: regular expression expected; use /pattern/ syntax"));
     default: {
diff --git a/src/qml/compiler/qv4codegen.cpp b/src/qml/compiler/qv4codegen.cpp
index 7a444e8c57..4130ad08d7 100644
--- a/src/qml/compiler/qv4codegen.cpp
+++ b/src/qml/compiler/qv4codegen.cpp
@@ -1058,6 +1058,8 @@ bool Codegen::visit(ArrayLiteral *ast)
             current->expr = _block->CONST(IR::MissingType, 0);
         }
         Result expr = expression(it->expression);
+        if (hasError)
+            return false;
 
         IR::ExprList *arg = _function->New<IR::ExprList>();
         if (!current) {
@@ -1100,6 +1102,8 @@ bool Codegen::visit(ArrayMemberExpression *ast)
 
     Result base = expression(ast->base);
     Result index = expression(ast->expression);
+    if (hasError)
+        return false;
     _expr.code = subscript(*base, *index);
     return false;
 }
@@ -1139,10 +1143,16 @@ bool Codegen::visit(BinaryExpression *ast)
 
             const unsigned r = _block->newTemp();
 
-            move(_block->TEMP(r), *expression(ast->left));
+            Result lhs = expression(ast->left);
+            if (hasError)
+                return false;
+            move(_block->TEMP(r), *lhs);
             setLocation(cjump(_block->TEMP(r), iftrue, endif), ast->operatorToken);
             _block = iftrue;
-            move(_block->TEMP(r), *expression(ast->right));
+            Result rhs = expression(ast->right);
+            if (hasError)
+                return false;
+            move(_block->TEMP(r), *rhs);
             _block->JUMP(endif);
 
             _expr.code = _block->TEMP(r);
@@ -1160,10 +1170,16 @@ bool Codegen::visit(BinaryExpression *ast)
             IR::BasicBlock *endif = _function->newBasicBlock(exceptionHandler());
 
             const unsigned r = _block->newTemp();
-            move(_block->TEMP(r), *expression(ast->left));
+            Result lhs = expression(ast->left);
+            if (hasError)
+                return false;
+            move(_block->TEMP(r), *lhs);
             setLocation(cjump(_block->TEMP(r), endif, iffalse), ast->operatorToken);
             _block = iffalse;
-            move(_block->TEMP(r), *expression(ast->right));
+            Result rhs = expression(ast->right);
+            if (hasError)
+                return false;
+            move(_block->TEMP(r), *rhs);
             _block->JUMP(endif);
 
             _block = endif;
@@ -1173,6 +1189,8 @@ bool Codegen::visit(BinaryExpression *ast)
     }
 
     IR::Expr* left = *expression(ast->left);
+    if (hasError)
+        return false;
 
     switch (ast->op) {
     case QSOperator::Or:
@@ -1182,17 +1200,19 @@ bool Codegen::visit(BinaryExpression *ast)
     case QSOperator::Assign: {
         if (throwSyntaxErrorOnEvalOrArgumentsInStrictMode(left, ast->left->lastSourceLocation()))
             return false;
-        IR::Expr* right = *expression(ast->right);
+        Result right = expression(ast->right);
+        if (hasError)
+            return false;
         if (!left->isLValue()) {
             throwReferenceError(ast->operatorToken, QStringLiteral("left-hand side of assignment operator is not an lvalue"));
             return false;
         }
 
         if (_expr.accept(nx)) {
-            move(left, right);
+            move(left, *right);
         } else {
             const unsigned t = _block->newTemp();
-            move(_block->TEMP(t), right);
+            move(_block->TEMP(t), *right);
             move(left, _block->TEMP(t));
             _expr.code = _block->TEMP(t);
         }
@@ -1212,17 +1232,19 @@ bool Codegen::visit(BinaryExpression *ast)
     case QSOperator::InplaceXor: {
         if (throwSyntaxErrorOnEvalOrArgumentsInStrictMode(left, ast->left->lastSourceLocation()))
             return false;
-        IR::Expr* right = *expression(ast->right);
+        Result right = expression(ast->right);
+        if (hasError)
+            return false;
         if (!left->isLValue()) {
             throwSyntaxError(ast->operatorToken, QStringLiteral("left-hand side of inplace operator is not an lvalue"));
             return false;
         }
 
         if (_expr.accept(nx)) {
-            move(left, right, baseOp(ast->op));
+            move(left, *right, baseOp(ast->op));
         } else {
             const unsigned t = _block->newTemp();
-            move(_block->TEMP(t), right);
+            move(_block->TEMP(t), *right);
             move(left, _block->TEMP(t), baseOp(ast->op));
             _expr.code = left;
         }
@@ -1245,12 +1267,14 @@ bool Codegen::visit(BinaryExpression *ast)
             left = _block->TEMP(t);
         }
 
-        IR::Expr* right = *expression(ast->right);
+        Result right = expression(ast->right);
+        if (hasError)
+            return false;
 
         if (_expr.accept(cx)) {
-            setLocation(cjump(binop(IR::binaryOperator(ast->op), left, right, ast->operatorToken), _expr.iftrue, _expr.iffalse), ast->operatorToken);
+            setLocation(cjump(binop(IR::binaryOperator(ast->op), left, *right, ast->operatorToken), _expr.iftrue, _expr.iffalse), ast->operatorToken);
         } else {
-            IR::Expr *e = binop(IR::binaryOperator(ast->op), left, right, ast->operatorToken);
+            IR::Expr *e = binop(IR::binaryOperator(ast->op), left, *right, ast->operatorToken);
             if (e->asConst() || e->asString())
                 _expr.code = e;
             else {
@@ -1279,9 +1303,11 @@ bool Codegen::visit(BinaryExpression *ast)
             left = _block->TEMP(t);
         }
 
-        IR::Expr* right = *expression(ast->right);
+        Result right = expression(ast->right);
+        if (hasError)
+            return false;
 
-        IR::Expr *e = binop(IR::binaryOperator(ast->op), left, right, ast->operatorToken);
+        IR::Expr *e = binop(IR::binaryOperator(ast->op), left, *right, ast->operatorToken);
         if (e->asConst() || e->asString())
             _expr.code = e;
         else {
@@ -1306,11 +1332,15 @@ bool Codegen::visit(CallExpression *ast)
     IR::ExprList *args = 0, **args_it = &args;
     for (ArgumentList *it = ast->arguments; it; it = it->next) {
         Result arg = expression(it->expression);
+        if (hasError)
+            return false;
         IR::Expr *actual = argument(*arg);
         *args_it = _function->New<IR::ExprList>();
         (*args_it)->init(actual);
         args_it = &(*args_it)->next;
     }
+    if (hasError)
+        return false;
     _expr.code = call(*base, args);
     return false;
 }
@@ -1329,11 +1359,17 @@ bool Codegen::visit(ConditionalExpression *ast)
     condition(ast->expression, iftrue, iffalse);
 
     _block = iftrue;
-    move(_block->TEMP(t), *expression(ast->ok));
+    Result ok = expression(ast->ok);
+    if (hasError)
+        return false;
+    move(_block->TEMP(t), *ok);
     _block->JUMP(endif);
 
     _block = iffalse;
-    move(_block->TEMP(t), *expression(ast->ko));
+    Result ko = expression(ast->ko);
+    if (hasError)
+        return false;
+    move(_block->TEMP(t), *ko);
     _block->JUMP(endif);
 
     _block = endif;
@@ -1349,6 +1385,8 @@ bool Codegen::visit(DeleteExpression *ast)
         return false;
 
     IR::Expr* expr = *expression(ast->expression);
+    if (hasError)
+        return false;
     // Temporaries cannot be deleted
     IR::ArgLocal *al = expr->asArgLocal();
     if (al && al->index < static_cast<unsigned>(_env->members.size())) {
@@ -1410,7 +1448,8 @@ bool Codegen::visit(FieldMemberExpression *ast)
         return false;
 
     Result base = expression(ast->base);
-    _expr.code = member(*base, _function->newString(ast->name.toString()));
+    if (!hasError)
+        _expr.code = member(*base, _function->newString(ast->name.toString()));
     return false;
 }
 
@@ -1501,6 +1540,8 @@ bool Codegen::visit(NewExpression *ast)
         return false;
 
     Result base = expression(ast->expression);
+    if (hasError)
+        return false;
     IR::Expr *expr = *base;
     if (expr && !expr->asTemp() && !expr->asArgLocal() && !expr->asName() && !expr->asMember()) {
         const unsigned t = _block->newTemp();
@@ -1517,6 +1558,8 @@ bool Codegen::visit(NewMemberExpression *ast)
         return false;
 
     Result base = expression(ast->base);
+    if (hasError)
+        return false;
     IR::Expr *expr = *base;
     if (expr && !expr->asTemp() && !expr->asArgLocal() && !expr->asName() && !expr->asMember()) {
         const unsigned t = _block->newTemp();
@@ -1527,6 +1570,8 @@ bool Codegen::visit(NewMemberExpression *ast)
     IR::ExprList *args = 0, **args_it = &args;
     for (ArgumentList *it = ast->arguments; it; it = it->next) {
         Result arg = expression(it->expression);
+        if (hasError)
+            return false;
         IR::Expr *actual = argument(*arg);
         *args_it = _function->New<IR::ExprList>();
         (*args_it)->init(actual);
@@ -1544,6 +1589,8 @@ bool Codegen::visit(NotExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     const unsigned r = _block->newTemp();
     setLocation(move(_block->TEMP(r), unop(IR::OpNot, *expr, ast->notToken)), ast->notToken);
     _expr.code = _block->TEMP(r);
@@ -1601,6 +1648,8 @@ bool Codegen::visit(ObjectLiteral *ast)
         QString name = it->assignment->name->asString();
         if (PropertyNameAndValue *nv = AST::cast<AST::PropertyNameAndValue *>(it->assignment)) {
             Result value = expression(nv->value);
+            if (hasError)
+                return false;
             ObjectPropertyValue &v = valueMap[name];
             if (v.hasGetter() || v.hasSetter() || (_function->isStrict && v.value)) {
                 throwSyntaxError(nv->lastSourceLocation(),
@@ -1731,6 +1780,8 @@ bool Codegen::visit(PostDecrementExpression *ast)
         return false;
 
     Result expr = expression(ast->base);
+    if (hasError)
+        return false;
     if (!expr->isLValue()) {
         throwReferenceError(ast->base->lastSourceLocation(), QStringLiteral("Invalid left-hand side expression in postfix operation"));
         return false;
@@ -1757,6 +1808,8 @@ bool Codegen::visit(PostIncrementExpression *ast)
         return false;
 
     Result expr = expression(ast->base);
+    if (hasError)
+        return false;
     if (!expr->isLValue()) {
         throwReferenceError(ast->base->lastSourceLocation(), QStringLiteral("Invalid left-hand side expression in postfix operation"));
         return false;
@@ -1783,6 +1836,8 @@ bool Codegen::visit(PreDecrementExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     if (!expr->isLValue()) {
         throwReferenceError(ast->expression->lastSourceLocation(), QStringLiteral("Prefix ++ operator applied to value that is not a reference."));
         return false;
@@ -1808,6 +1863,8 @@ bool Codegen::visit(PreIncrementExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     if (!expr->isLValue()) {
         throwReferenceError(ast->expression->lastSourceLocation(), QStringLiteral("Prefix ++ operator applied to value that is not a reference."));
         return false;
@@ -1860,6 +1917,8 @@ bool Codegen::visit(TildeExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     const unsigned t = _block->newTemp();
     setLocation(move(_block->TEMP(t), unop(IR::OpCompl, *expr, ast->tildeToken)), ast->tildeToken);
     _expr.code = _block->TEMP(t);
@@ -1885,6 +1944,8 @@ bool Codegen::visit(TypeOfExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     IR::ExprList *args = _function->New<IR::ExprList>();
     args->init(reference(*expr));
     _expr.code = call(_block->NAME(IR::Name::builtin_typeof, ast->typeofToken.startLine, ast->typeofToken.startColumn), args);
@@ -1897,6 +1958,8 @@ bool Codegen::visit(UnaryMinusExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     const unsigned t = _block->newTemp();
     setLocation(move(_block->TEMP(t), unop(IR::OpUMinus, *expr, ast->minusToken)), ast->minusToken);
     _expr.code = _block->TEMP(t);
@@ -1909,6 +1972,8 @@ bool Codegen::visit(UnaryPlusExpression *ast)
         return false;
 
     Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
     const unsigned t = _block->newTemp();
     setLocation(move(_block->TEMP(t), unop(IR::OpUPlus, *expr, ast->plusToken)), ast->plusToken);
     _expr.code = _block->TEMP(t);
@@ -2224,7 +2289,10 @@ bool Codegen::visit(ForEachStatement *ast)
     IR::BasicBlock *foreachend = _function->newBasicBlock(exceptionHandler());
 
     int objectToIterateOn = _block->newTemp();
-    move(_block->TEMP(objectToIterateOn), *expression(ast->expression));
+    Result expr = expression(ast->expression);
+    if (hasError)
+        return false;
+    move(_block->TEMP(objectToIterateOn), *expr);
     IR::ExprList *args = _function->New<IR::ExprList>();
     args->init(_block->TEMP(objectToIterateOn));
 
@@ -2236,7 +2304,10 @@ bool Codegen::visit(ForEachStatement *ast)
 
     _block = foreachbody;
     int temp = _block->newTemp();
-    move(*expression(ast->initialiser), _block->TEMP(temp));
+    Result init = expression(ast->initialiser);
+    if (hasError)
+        return false;
+    move(*init, _block->TEMP(temp));
     statement(ast->statement);
     _block->JUMP(foreachin);
 
@@ -2726,7 +2797,10 @@ bool Codegen::visit(WithStatement *ast)
     _function->hasWith = true;
 
     const int withObject = _block->newTemp();
-    _block->MOVE(_block->TEMP(withObject), *expression(ast->expression));
+    Result src = expression(ast->expression);
+    if (hasError)
+        return false;
+    _block->MOVE(_block->TEMP(withObject), *src);
 
     // need an exception handler for with to cleanup the with scope
     IR::BasicBlock *withExceptionHandler = _function->newBasicBlock(exceptionHandler());
diff --git a/src/qml/doc/src/cppintegration/data.qdoc b/src/qml/doc/src/cppintegration/data.qdoc
index 0d875bd10f..7bb4d701e2 100644
--- a/src/qml/doc/src/cppintegration/data.qdoc
+++ b/src/qml/doc/src/cppintegration/data.qdoc
@@ -381,6 +381,8 @@ Message {
  }
 \endqml
 
+To use an enum as a \l {QFlags}{flags} type in QML, see \l Q_FLAG().
+
 \note The names of enum values must begin with a capital letter in order to
 be accessible from QML.
 
diff --git a/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc b/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc
index 04d0d0ed2e..de0515e5d0 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/objectattributes.qdoc
@@ -729,7 +729,7 @@ Rectangle {
     MouseArea {
         anchors.fill: parent
         onPressed: root.activated(mouse.x, mouse.y)
-        onRelased: root.deactivated()
+        onReleased: root.deactivated()
     }
 }
 \endqml
diff --git a/src/qml/jsruntime/qv4internalclass.cpp b/src/qml/jsruntime/qv4internalclass.cpp
index f46f581168..bac45e18c8 100644
--- a/src/qml/jsruntime/qv4internalclass.cpp
+++ b/src/qml/jsruntime/qv4internalclass.cpp
@@ -147,8 +147,8 @@ static void insertHoleIntoPropertyData(Object *object, int idx)
 static void removeFromPropertyData(Object *object, int idx, bool accessor = false)
 {
     int inlineSize = object->d()->inlineMemberSize;
-    int icSize = object->internalClass()->size;
     int delta = (accessor ? 2 : 1);
+    int oldSize = object->internalClass()->size + delta;
     int to = idx;
     int from = to + delta;
     if (from < inlineSize) {
@@ -156,15 +156,15 @@ static void removeFromPropertyData(Object *object, int idx, bool accessor = fals
         to = inlineSize - delta;
         from = inlineSize;
     }
-    if (to < inlineSize && from < icSize) {
+    if (to < inlineSize && from < oldSize) {
         Q_ASSERT(from >= inlineSize);
         memcpy(object->propertyData(to), object->d()->propertyData(from), (inlineSize - to)*sizeof(Value));
         to = inlineSize;
         from = inlineSize + delta;
     }
-    if (from < icSize + delta) {
+    if (from < oldSize) {
         Q_ASSERT(to >= inlineSize && from > to);
-        memmove(object->propertyData(to), object->d()->propertyData(from), (icSize + delta - to)*sizeof(Value));
+        memmove(object->propertyData(to), object->d()->propertyData(from), (oldSize - to)*sizeof(Value));
     }
 }
 
diff --git a/src/qml/jsruntime/qv4value_p.h b/src/qml/jsruntime/qv4value_p.h
index d24a5c4c76..dae4d11767 100644
--- a/src/qml/jsruntime/qv4value_p.h
+++ b/src/qml/jsruntime/qv4value_p.h
@@ -102,13 +102,13 @@ public:
     Q_ALWAYS_INLINE quint64 rawValue() const { return _val; }
     Q_ALWAYS_INLINE void setRawValue(quint64 raw) { _val = raw; }
 
-#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN || defined(QV4_USE_64_BIT_VALUE_ENCODING)
     static inline int valueOffset() { return 0; }
     static inline int tagOffset() { return 4; }
     Q_ALWAYS_INLINE void setTagValue(quint32 tag, quint32 value) { _val = quint64(tag) << 32 | value; }
     Q_ALWAYS_INLINE quint32 value() const { return _val & quint64(~quint32(0)); }
     Q_ALWAYS_INLINE quint32 tag() const { return _val >> 32; }
-#else // !Q_LITTLE_ENDIAN
+#else // !Q_LITTLE_ENDIAN && !defined(QV4_USE_64_BIT_VALUE_ENCODING)
     static inline int valueOffset() { return 4; }
     static inline int tagOffset() { return 0; }
     Q_ALWAYS_INLINE void setTagValue(quint32 tag, quint32 value) { _val = quint64(value) << 32 | tag; }
diff --git a/src/qml/qml/qqmlcomponent.cpp b/src/qml/qml/qqmlcomponent.cpp
index 175b84e7c5..9c7b4fe1c0 100644
--- a/src/qml/qml/qqmlcomponent.cpp
+++ b/src/qml/qml/qqmlcomponent.cpp
@@ -1135,7 +1135,7 @@ static void QQmlComponent_setQmlParent(QObject *me, QObject *parent)
 }
 
 /*!
-    \qmlmethod object Component::createObject(Item parent, object properties)
+    \qmlmethod object Component::createObject(QtObject parent, object properties)
 
     Creates and returns an object instance of this component that will have
     the given \a parent and \a properties. The \a properties argument is optional.
diff --git a/src/qml/qml/qqmlobjectcreator.cpp b/src/qml/qml/qqmlobjectcreator.cpp
index f2b3276778..3000f3e695 100644
--- a/src/qml/qml/qqmlobjectcreator.cpp
+++ b/src/qml/qml/qqmlobjectcreator.cpp
@@ -480,6 +480,17 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &value, propertyWriteFlags);
     }
     break;
+    case QVariant::Vector2D: {
+        struct {
+            float xp;
+            float yp;
+        } vec;
+        bool ok = QQmlStringConverters::createFromString(QMetaType::QVector2D, binding->valueAsString(qmlUnit), &vec, sizeof(vec));
+        Q_ASSERT(ok);
+        Q_UNUSED(ok);
+        property->writeProperty(_qobject, &vec, propertyWriteFlags);
+    }
+    break;
     case QVariant::Vector3D: {
         struct {
             float xp;
@@ -505,6 +516,19 @@ void QQmlObjectCreator::setPropertyValue(const QQmlPropertyData *property, const
         property->writeProperty(_qobject, &vec, propertyWriteFlags);
     }
     break;
+    case QVariant::Quaternion: {
+        struct {
+            float wp;
+            float xp;
+            float yp;
+            float zp;
+        } vec;
+        bool ok = QQmlStringConverters::createFromString(QMetaType::QQuaternion, binding->valueAsString(qmlUnit), &vec, sizeof(vec));
+        Q_ASSERT(ok);
+        Q_UNUSED(ok);
+        property->writeProperty(_qobject, &vec, propertyWriteFlags);
+    }
+    break;
     case QVariant::RegExp:
         Q_ASSERT(!"not possible");
         break;
diff --git a/src/qml/qml/qqmlopenmetaobject.cpp b/src/qml/qml/qqmlopenmetaobject.cpp
index 22c4072aec..0fd9e63bde 100644
--- a/src/qml/qml/qqmlopenmetaobject.cpp
+++ b/src/qml/qml/qqmlopenmetaobject.cpp
@@ -278,7 +278,7 @@ int QQmlOpenMetaObject::metaCall(QObject *o, QMetaObject::Call c, int id, void *
             propertyRead(propId);
             *reinterpret_cast<QVariant *>(a[0]) = d->getData(propId);
         } else if (c == QMetaObject::WriteProperty) {
-            if (propId <= d->data.count() || d->data[propId].first != *reinterpret_cast<QVariant *>(a[0]))  {
+            if (propId >= d->data.count() || d->data[propId].first != *reinterpret_cast<QVariant *>(a[0]))  {
                 propertyWrite(propId);
                 QPair<QVariant, bool> &prop = d->getDataRef(propId);
                 prop.first = propertyWriteValue(propId, *reinterpret_cast<QVariant *>(a[0]));
diff --git a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
index cb281a2d4a..a764402c2f 100644
--- a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
+++ b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
@@ -156,6 +156,111 @@ with list models of QAbstractItemModel type:
 \li \l DelegateModel::parentModelIndex() returns a QModelIndex which can be assigned to DelegateModel::rootIndex
 \endlist
 
+\section2 SQL Models
+
+Qt provides C++ classes that support SQL data models. These classes work
+transparently on the underlying SQL data, reducing the need to run SQL
+queries for basic SQL operations such as create, insert, or update.
+For more details about these classes, see \l{Using the SQL Model Classes}.
+
+Although the C++ classes provide complete feature sets to operate on SQL
+data, they do not provide data access to QML. So you must implement a
+C++ custom data model as a subclass of one of these classes, and expose it
+to QML either as a type or context property.
+
+\section3 Read-only Data Model
+
+The custom model must reimplement the following methods to enable read-only
+access to the data from QML:
+
+\list
+\li \l{QAbstractItemModel::}{roleNames}() to expose the role names to the
+    QML frontend. For example, the following version returns the selected
+    table's field names as role names:
+    \code
+     QHash<int, QByteArray> SqlQueryModel::roleNames() const
+     {
+        QHash<int, QByteArray> roles;
+        // record() returns an empty QSqlRecord
+        for (int i = 0; i < this->record().count(); i ++) {
+            roles.insert(Qt::UserRole + i + 1, record().fieldName(i).toUtf8());
+        }
+        return roles;
+    }
+    \endcode
+\li \l{QSqlQueryModel::}{data}() to expose SQL data to the QML frontend.
+    For example, the following implementation returns data for the given
+    model index:
+    \code
+    QVariant SqlQueryModel::data(const QModelIndex &index, int role) const
+    {
+        QVariant value;
+
+        if (index.isValid()) {
+            if (role < Qt::UserRole) {
+                value = QSqlQueryModel::data(index, role);
+            } else {
+                int columnIdx = role - Qt::UserRole - 1;
+                QModelIndex modelIndex = this->index(index.row(), columnIdx);
+                value = QSqlQueryModel::data(modelIndex, Qt::DisplayRole);
+            }
+        }
+        return value;
+    }
+    \endcode
+\endlist
+
+The QSqlQueryModel class is good enough to implement a custom read-only
+model that represents data in an SQL database. The
+\l{Qt Quick Controls 2 - Chat Tutorial}{chat tutorial} example
+demonstrates this very well by implementing a custom model to fetch the
+contact details from an SQLite database.
+
+\section3 Editable Data Model
+
+Besides the \c roleNames() and \c data(), the editable models must reimplement
+the \l{QSqlTableModel::}{setData} method to save changes to existing SQL data.
+The following version of the method checks if the given model index is valid
+and the \c role is equal to \l Qt::EditRole, before calling the parent class
+version:
+
+\code
+bool SqlEditableModel::setData(const QModelIndex &item, const QVariant &value, int role)
+{
+    if (item.isValid() && role == Qt::EditRole) {
+        QSqlTableModel::setData(item, value,role);
+        emit dataChanged(item, item);
+        return true;
+    }
+    return false;
+
+}
+\endcode
+
+\note It is important to emit the \l{QAbstractItemModel::}{dataChanged}()
+signal after saving the changes.
+
+Unlike the C++ item views such as QListView or QTableView, the \c setData()
+method must be explicitly invoked from QML whenever appropriate. For example,
+on the \l[QML]{TextField::}{editingFinished}() or \l[QML]{TextField::}{accepted}()
+signal of \l[QtQuickControls]{TextField}. Depending on the
+\l{QSqlTableModel::}{EditStrategy} used by the model, the changes are either
+queued for submission later or submitted immediately.
+
+You can also insert new data into the model by calling
+\l {QSqlTableModel::insertRecord}(). In the following example snippet,
+a QSqlRecord is populated with book details and appended to the
+model:
+
+\code
+    ...
+    QSqlRecord newRecord = record();
+    newRecord.setValue("author", "John Grisham");
+    newRecord.setValue("booktitle", "The Litigators");
+    insertRecord(rowCount(), newRecord);
+    ...
+\endcode
+
 \section2 Exposing C++ Data Models to QML
 
 The above examples use QQmlContext::setContextProperty() to set
diff --git a/src/quick/items/qquickflickable.cpp b/src/quick/items/qquickflickable.cpp
index a09088dfed..dcba5c2d71 100644
--- a/src/quick/items/qquickflickable.cpp
+++ b/src/quick/items/qquickflickable.cpp
@@ -1590,13 +1590,13 @@ qreal QQuickFlickable::minXExtent() const
 qreal QQuickFlickable::maxXExtent() const
 {
     Q_D(const QQuickFlickable);
-    return qMin<qreal>(0, width() - vWidth() - d->hData.endMargin);
+    return qMin<qreal>(minXExtent(), width() - vWidth() - d->hData.endMargin);
 }
 /* returns -ve */
 qreal QQuickFlickable::maxYExtent() const
 {
     Q_D(const QQuickFlickable);
-    return qMin<qreal>(0, height() - vHeight() - d->vData.endMargin);
+    return qMin<qreal>(minYExtent(), height() - vHeight() - d->vData.endMargin);
 }
 
 void QQuickFlickable::componentComplete()
diff --git a/src/quick/items/qquickitem.cpp b/src/quick/items/qquickitem.cpp
index 07a415eecd..8905faf973 100644
--- a/src/quick/items/qquickitem.cpp
+++ b/src/quick/items/qquickitem.cpp
@@ -2090,6 +2090,9 @@ void QQuickItemPrivate::updateSubFocusItem(QQuickItem *scope, bool focus)
     \value ItemDevicePixelRatioHasChanged The device pixel ratio of the screen
     the item is on has changed. ItemChangedData::realValue contains the new
     device pixel ratio.
+
+    \value ItemAntialiasingHasChanged The antialiasing has changed. The current
+    (boolean) value can be found in QQuickItem::antialiasing.
 */
 
 /*!
diff --git a/src/quick/items/qquickitemanimation.cpp b/src/quick/items/qquickitemanimation.cpp
index 962f410095..027c07ec07 100644
--- a/src/quick/items/qquickitemanimation.cpp
+++ b/src/quick/items/qquickitemanimation.cpp
@@ -200,6 +200,27 @@ QPointF QQuickParentAnimationPrivate::computeTransformOrigin(QQuickItem::Transfo
     }
 }
 
+struct QQuickParentAnimationData : public QAbstractAnimationAction
+{
+    QQuickParentAnimationData() : reverse(false) {}
+    ~QQuickParentAnimationData() { qDeleteAll(pc); }
+
+    QQuickStateActions actions;
+    //### reverse should probably apply on a per-action basis
+    bool reverse;
+    QList<QQuickParentChange *> pc;
+    void doAction() Q_DECL_OVERRIDE
+    {
+        for (int ii = 0; ii < actions.count(); ++ii) {
+            const QQuickStateAction &action = actions.at(ii);
+            if (reverse)
+                action.event->reverse();
+            else
+                action.event->execute();
+        }
+    }
+};
+
 QAbstractAnimationJob* QQuickParentAnimation::transition(QQuickStateActions &actions,
                         QQmlProperties &modified,
                         TransitionDirection direction,
@@ -207,27 +228,6 @@ QAbstractAnimationJob* QQuickParentAnimation::transition(QQuickStateActions &act
 {
     Q_D(QQuickParentAnimation);
 
-    struct QQuickParentAnimationData : public QAbstractAnimationAction
-    {
-        QQuickParentAnimationData() : reverse(false) {}
-        ~QQuickParentAnimationData() { qDeleteAll(pc); }
-
-        QQuickStateActions actions;
-        //### reverse should probably apply on a per-action basis
-        bool reverse;
-        QList<QQuickParentChange *> pc;
-        void doAction() Q_DECL_OVERRIDE
-        {
-            for (int ii = 0; ii < actions.count(); ++ii) {
-                const QQuickStateAction &action = actions.at(ii);
-                if (reverse)
-                    action.event->reverse();
-                else
-                    action.event->execute();
-            }
-        }
-    };
-
     QQuickParentAnimationData *data = new QQuickParentAnimationData;
     QQuickParentAnimationData *viaData = new QQuickParentAnimationData;
 
diff --git a/src/quick/items/qquicktextedit.cpp b/src/quick/items/qquicktextedit.cpp
index eb568c48d4..d6d9d53a3b 100644
--- a/src/quick/items/qquicktextedit.cpp
+++ b/src/quick/items/qquicktextedit.cpp
@@ -1489,8 +1489,8 @@ void QQuickTextEdit::setSelectByKeyboard(bool on)
 
     If true, the user can use the mouse to select text in some
     platform-specific way. Note that for some platforms this may
-    not be an appropriate interaction (eg. may conflict with how
-    the text needs to behave inside a Flickable.
+    not be an appropriate interaction; it may conflict with how
+    the text needs to behave inside a Flickable, for example.
 */
 bool QQuickTextEdit::selectByMouse() const
 {
diff --git a/src/quick/items/qquickwindow.cpp b/src/quick/items/qquickwindow.cpp
index 56466fdbd1..a2c82c30a0 100644
--- a/src/quick/items/qquickwindow.cpp
+++ b/src/quick/items/qquickwindow.cpp
@@ -707,10 +707,10 @@ bool QQuickWindowPrivate::translateTouchToMouse(QQuickItem *item, QTouchEvent *e
                     lastMousePosition = me->windowPos();
 
                     bool accepted = me->isAccepted();
-                    bool delivered = deliverHoverEvent(contentItem, me->windowPos(), last, me->modifiers(), accepted);
+                    bool delivered = deliverHoverEvent(contentItem, me->windowPos(), last, me->modifiers(), me->timestamp(), accepted);
                     if (!delivered) {
                         //take care of any exits
-                        accepted = clearHover();
+                        accepted = clearHover(me->timestamp());
                     }
                     me->setAccepted(accepted);
                     break;
@@ -1488,7 +1488,7 @@ QQuickItem *QQuickWindow::mouseGrabberItem() const
 }
 
 
-bool QQuickWindowPrivate::clearHover()
+bool QQuickWindowPrivate::clearHover(ulong timestamp)
 {
     Q_Q(QQuickWindow);
     if (hoverItems.isEmpty())
@@ -1498,7 +1498,7 @@ bool QQuickWindowPrivate::clearHover()
 
     bool accepted = false;
     foreach (QQuickItem* item, hoverItems)
-        accepted = sendHoverEvent(QEvent::HoverLeave, item, pos, pos, QGuiApplication::keyboardModifiers(), true) || accepted;
+        accepted = sendHoverEvent(QEvent::HoverLeave, item, pos, pos, QGuiApplication::keyboardModifiers(), timestamp, true) || accepted;
     hoverItems.clear();
     return accepted;
 }
@@ -1678,6 +1678,12 @@ bool QQuickWindowPrivate::deliverMouseEvent(QMouseEvent *event)
     }
 
     if (mouseGrabberItem) {
+        if (event->button() != Qt::NoButton
+            && mouseGrabberItem->acceptedMouseButtons()
+            && !(mouseGrabberItem->acceptedMouseButtons() & event->button())) {
+            event->ignore();
+            return false;
+        }
         QPointF localPos = mouseGrabberItem->mapFromScene(event->windowPos());
         QScopedPointer<QMouseEvent> me(cloneMouseEvent(event, &localPos));
         me->accept();
@@ -1692,13 +1698,15 @@ bool QQuickWindowPrivate::deliverMouseEvent(QMouseEvent *event)
 
 bool QQuickWindowPrivate::sendHoverEvent(QEvent::Type type, QQuickItem *item,
                                       const QPointF &scenePos, const QPointF &lastScenePos,
-                                      Qt::KeyboardModifiers modifiers, bool accepted)
+                                      Qt::KeyboardModifiers modifiers, ulong timestamp,
+                                      bool accepted)
 {
     Q_Q(QQuickWindow);
     const QTransform transform = QQuickItemPrivate::get(item)->windowToItemTransform();
 
     //create copy of event
     QHoverEvent hoverEvent(type, transform.map(scenePos), transform.map(lastScenePos), modifiers);
+    hoverEvent.setTimestamp(timestamp);
     hoverEvent.setAccepted(accepted);
 
     QSet<QQuickItem *> hasFiltered;
@@ -1712,7 +1720,7 @@ bool QQuickWindowPrivate::sendHoverEvent(QEvent::Type type, QQuickItem *item,
 }
 
 bool QQuickWindowPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &scenePos, const QPointF &lastScenePos,
-                                         Qt::KeyboardModifiers modifiers, bool &accepted)
+                                         Qt::KeyboardModifiers modifiers, ulong timestamp, bool &accepted)
 {
     Q_Q(QQuickWindow);
     QQuickItemPrivate *itemPrivate = QQuickItemPrivate::get(item);
@@ -1730,7 +1738,7 @@ bool QQuickWindowPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &sce
             QQuickItem *child = children.at(ii);
             if (!child->isVisible() || !child->isEnabled() || QQuickItemPrivate::get(child)->culled)
                 continue;
-            if (deliverHoverEvent(child, scenePos, lastScenePos, modifiers, accepted))
+            if (deliverHoverEvent(child, scenePos, lastScenePos, modifiers, timestamp, accepted))
                 return true;
         }
     }
@@ -1740,7 +1748,7 @@ bool QQuickWindowPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &sce
         if (item->contains(p)) {
             if (!hoverItems.isEmpty() && hoverItems[0] == item) {
                 //move
-                accepted = sendHoverEvent(QEvent::HoverMove, item, scenePos, lastScenePos, modifiers, accepted);
+                accepted = sendHoverEvent(QEvent::HoverMove, item, scenePos, lastScenePos, modifiers, timestamp, accepted);
             } else {
                 QList<QQuickItem *> itemsToHover;
                 QQuickItem* parent = item;
@@ -1751,12 +1759,12 @@ bool QQuickWindowPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &sce
                 // Leaving from previous hovered items until we reach the item or one of its ancestors.
                 while (!hoverItems.isEmpty() && !itemsToHover.contains(hoverItems[0])) {
                     QQuickItem *hoverLeaveItem = hoverItems.takeFirst();
-                    sendHoverEvent(QEvent::HoverLeave, hoverLeaveItem, scenePos, lastScenePos, modifiers, accepted);
+                    sendHoverEvent(QEvent::HoverLeave, hoverLeaveItem, scenePos, lastScenePos, modifiers, timestamp, accepted);
                 }
 
                 if (!hoverItems.isEmpty() && hoverItems[0] == item){//Not entering a new Item
                     // ### Shouldn't we send moves for the parent items as well?
-                    accepted = sendHoverEvent(QEvent::HoverMove, item, scenePos, lastScenePos, modifiers, accepted);
+                    accepted = sendHoverEvent(QEvent::HoverMove, item, scenePos, lastScenePos, modifiers, timestamp, accepted);
                 } else {
                     // Enter items that are not entered yet.
                     int startIdx = -1;
@@ -1775,7 +1783,7 @@ bool QQuickWindowPrivate::deliverHoverEvent(QQuickItem *item, const QPointF &sce
                         // itemToHoverPrivate->window here prevents that case.
                         if (itemToHoverPrivate->window == q && itemToHoverPrivate->hoverEnabled) {
                             hoverItems.prepend(itemToHover);
-                            sendHoverEvent(QEvent::HoverEnter, itemToHover, scenePos, lastScenePos, modifiers, accepted);
+                            sendHoverEvent(QEvent::HoverEnter, itemToHover, scenePos, lastScenePos, modifiers, timestamp, accepted);
                         }
                     }
                 }
@@ -2076,10 +2084,10 @@ void QQuickWindowPrivate::handleMouseEvent(QMouseEvent *event)
             lastMousePosition = event->windowPos();
 
             bool accepted = event->isAccepted();
-            bool delivered = deliverHoverEvent(contentItem, event->windowPos(), last, event->modifiers(), accepted);
+            bool delivered = deliverHoverEvent(contentItem, event->windowPos(), last, event->modifiers(), event->timestamp(), accepted);
             if (!delivered) {
                 //take care of any exits
-                accepted = clearHover();
+                accepted = clearHover(event->timestamp());
             }
             event->setAccepted(accepted);
             return;
@@ -2110,7 +2118,7 @@ void QQuickWindowPrivate::flushFrameSynchronousEvents()
     // whether it has moved into a position where it is now under the cursor.
     if (!mouseGrabberItem && !lastMousePosition.isNull()) {
         bool accepted = false;
-        bool delivered = deliverHoverEvent(contentItem, lastMousePosition, lastMousePosition, QGuiApplication::keyboardModifiers(), accepted);
+        bool delivered = deliverHoverEvent(contentItem, lastMousePosition, lastMousePosition, QGuiApplication::keyboardModifiers(), 0, accepted);
         if (!delivered)
             clearHover(); // take care of any exits
     }
diff --git a/src/quick/items/qquickwindow_p.h b/src/quick/items/qquickwindow_p.h
index 71f2bb5778..40a361a897 100644
--- a/src/quick/items/qquickwindow_p.h
+++ b/src/quick/items/qquickwindow_p.h
@@ -165,14 +165,14 @@ public:
     bool deliverTouchCancelEvent(QTouchEvent *);
     void deliverDelayedTouchEvent();
     void flushFrameSynchronousEvents();
-    bool deliverHoverEvent(QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, bool &accepted);
+    bool deliverHoverEvent(QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos, Qt::KeyboardModifiers modifiers, ulong timestamp, bool &accepted);
     bool deliverMatchingPointsToItem(QQuickItem *item, QTouchEvent *event, QSet<int> *acceptedNewPoints, const QSet<int> &matchingNewPoints, const QList<QTouchEvent::TouchPoint> &matchingPoints, QSet<QQuickItem*> *filtered);
     static QTouchEvent *touchEventForItem(QQuickItem *target, const QTouchEvent &originalEvent, bool alwaysCheckBounds = false);
     static QTouchEvent *touchEventWithPoints(const QTouchEvent &event, const QList<QTouchEvent::TouchPoint> &newPoints);
     bool sendFilteredTouchEvent(QQuickItem *target, QQuickItem *item, QTouchEvent *event, QSet<QQuickItem*> *filtered);
     bool sendHoverEvent(QEvent::Type, QQuickItem *, const QPointF &scenePos, const QPointF &lastScenePos,
-                        Qt::KeyboardModifiers modifiers, bool accepted);
-    bool clearHover();
+                        Qt::KeyboardModifiers modifiers, ulong timestamp, bool accepted);
+    bool clearHover(ulong timestamp = 0);
 #ifndef QT_NO_DRAGANDDROP
     void deliverDragEvent(QQuickDragGrabber *, QEvent *);
     bool deliverDragEvent(QQuickDragGrabber *, QQuickItem *, QDragMoveEvent *);
diff --git a/src/quick/scenegraph/qsgthreadedrenderloop.cpp b/src/quick/scenegraph/qsgthreadedrenderloop.cpp
index 3ff32b360d..6b9c67b2bd 100644
--- a/src/quick/scenegraph/qsgthreadedrenderloop.cpp
+++ b/src/quick/scenegraph/qsgthreadedrenderloop.cpp
@@ -600,7 +600,7 @@ void QSGRenderThread::syncAndRender()
 #endif
     Q_QUICK_SG_PROFILE_RECORD(QQuickProfiler::SceneGraphRenderLoopFrame);
 
-    if (!syncResultedInChanges && !repaintRequested) {
+    if (!syncResultedInChanges && !repaintRequested && sgrc->isValid()) {
         qCDebug(QSG_LOG_RENDERLOOP) << QSG_RT_PAD << "- no changes, render aborted";
         int waitTime = vsyncDelta - (int) waitTimer.elapsed();
         if (waitTime > 0)
diff --git a/src/quick/scenegraph/util/qsgatlastexture.cpp b/src/quick/scenegraph/util/qsgatlastexture.cpp
index 098a4a666b..40c3293c7b 100644
--- a/src/quick/scenegraph/util/qsgatlastexture.cpp
+++ b/src/quick/scenegraph/util/qsgatlastexture.cpp
@@ -158,13 +158,13 @@ Atlas::Atlas(const QSize &size)
         wrongfullyReportsBgra8888Support = false;
 
     const char *ext = (const char *) QOpenGLContext::currentContext()->functions()->glGetString(GL_EXTENSIONS);
-    if (!wrongfullyReportsBgra8888Support
+    if (ext && !wrongfullyReportsBgra8888Support
             && (strstr(ext, "GL_EXT_bgra")
                 || strstr(ext, "GL_EXT_texture_format_BGRA8888")
                 || strstr(ext, "GL_IMG_texture_format_BGRA8888"))) {
         m_internalFormat = m_externalFormat = GL_BGRA;
 #if defined(Q_OS_DARWIN) && !defined(Q_OS_OSX)
-    } else if (strstr(ext, "GL_APPLE_texture_format_BGRA8888")) {
+    } else if (ext && strstr(ext, "GL_APPLE_texture_format_BGRA8888")) {
         m_internalFormat = GL_RGBA;
         m_externalFormat = GL_BGRA;
 #endif // IOS || TVOS