Merge remote-tracking branch 'origin/5.9' into 5.10

Change-Id: I41ca9120a470a905c2f5c168c1de4cf970fa0fff

24 files changed, 500 insertions, 110 deletions

diff --git a/src/qml/compiler/qqmlirbuilder.cpp b/src/qml/compiler/qqmlirbuilder.cpp
index 184925f167..60aea8e894 100644
--- a/src/qml/compiler/qqmlirbuilder.cpp
+++ b/src/qml/compiler/qqmlirbuilder.cpp
@@ -1466,6 +1466,9 @@ QV4::CompiledData::Unit *QmlUnitGenerator::generate(Document &output, const QV4:
     QV4::CompiledData::Unit *qmlUnit = reinterpret_cast<QV4::CompiledData::Unit *>(data);
     qmlUnit->unitSize = totalSize;
     qmlUnit->flags |= QV4::CompiledData::Unit::IsQml;
+    // This unit's memory was allocated with malloc on the heap, so it's
+    // definitely not suitable for StaticData access.
+    qmlUnit->flags &= ~QV4::CompiledData::Unit::StaticData;
     qmlUnit->offsetToImports = unitSize;
     qmlUnit->nImports = output.imports.count();
     qmlUnit->offsetToObjects = unitSize + importSize;
diff --git a/src/qml/doc/src/qmlfunctions.qdoc b/src/qml/doc/src/qmlfunctions.qdoc
index 8a62a18eec..f939ddbcf3 100644
--- a/src/qml/doc/src/qmlfunctions.qdoc
+++ b/src/qml/doc/src/qmlfunctions.qdoc
@@ -324,6 +324,19 @@
    qmlRegisterSingletonType("Qt.example.qjsvalueApi", 1, 0, "MyApi", example_qjsvalue_singletontype_provider);
    \endcode
 
+   Alternatively, you can use a C++11 lambda:
+
+   \code
+   qmlRegisterSingletonType("Qt.example.qjsvalueApi", 1, 0, "MyApi", [](QQmlEngine *engine, QJSEngine *scriptEngine) -> QJSValue {
+       Q_UNUSED(engine)
+
+       static int seedValue = 5;
+       QJSValue example = scriptEngine->newObject();
+       example.setProperty("someProperty", seedValue++);
+       return example;
+   });
+   \endcode
+
    In order to use the registered singleton type in QML, you must import the singleton type.
    \qml
    import QtQuick 2.0
@@ -423,6 +436,18 @@
    qmlRegisterSingletonType<SingletonTypeExample>("Qt.example.qobjectSingleton", 1, 0, "MyApi", example_qobject_singletontype_provider);
    \endcode
 
+   Alternatively, you can use a C++11 lambda:
+
+   \code
+   qmlRegisterSingletonType<SingletonTypeExample>("Qt.example.qjsvalueApi", 1, 0, "MyApi", [](QQmlEngine *engine, QJSEngine *scriptEngine) -> QObject * {
+       Q_UNUSED(engine)
+       Q_UNUSED(scriptEngine)
+
+       SingletonTypeExample *example = new SingletonTypeExample();
+       return example;
+   });
+   \endcode
+
    In order to use the registered singleton type in QML, you must import the singleton type.
    \qml
    import QtQuick 2.0
diff --git a/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc b/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc
index 1b645a94c0..9eb8f72cf2 100644
--- a/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc
+++ b/src/qml/doc/src/qmllanguageref/syntax/basics.qdoc
@@ -38,6 +38,8 @@ imperative code, in the case where complex custom application behavior is needed
 
 QML source code is generally loaded by the engine through QML \e documents, which are
 standalone documents of QML code. These can be used to define \l {QML Object Types}{QML object types} that can then be reused throughout an application.
+Note that type names must begin with an uppercase letter in order
+to be declared as QML object types in a QML file.
 
 
 \section1 Import Statements
diff --git a/src/qml/doc/src/qmllanguageref/typesystem/objecttypes.qdoc b/src/qml/doc/src/qmllanguageref/typesystem/objecttypes.qdoc
index b74646b7d0..5f089b5ebc 100644
--- a/src/qml/doc/src/qmllanguageref/typesystem/objecttypes.qdoc
+++ b/src/qml/doc/src/qmllanguageref/typesystem/objecttypes.qdoc
@@ -45,6 +45,8 @@ type, as discussed in \l {qtqml-documents-definetypes.html}
 {Documents as QML object type definitions}, or by defining a QML type from C++
 and registering the type with the QML engine, as discussed in
 \l{qtqml-cppintegration-definetypes.html}{Defining QML Types from C++}.
+Note that in both cases, the type name must begin with an uppercase letter in
+order to be declared as a QML object type in a QML file.
 
 
 \section1 Defining Object Types from QML
diff --git a/src/qml/jsruntime/qv4persistent.cpp b/src/qml/jsruntime/qv4persistent.cpp
index 0b31c971f9..973541553a 100644
--- a/src/qml/jsruntime/qv4persistent.cpp
+++ b/src/qml/jsruntime/qv4persistent.cpp
@@ -68,6 +68,22 @@ Page *getPage(Value *val) {
    return reinterpret_cast<Page *>(reinterpret_cast<quintptr>(val) & ~((quintptr)(WTF::pageSize() - 1)));
 }
 
+QML_NEARLY_ALWAYS_INLINE void insertInFront(PersistentValueStorage *storage, Page *p)
+{
+    p->header.next = reinterpret_cast<Page *>(storage->firstPage);
+    p->header.prev = reinterpret_cast<Page **>(&storage->firstPage);
+    if (p->header.next)
+        p->header.next->header.prev = &p->header.next;
+    storage->firstPage = p;
+}
+
+QML_NEARLY_ALWAYS_INLINE void unlink(Page *p)
+{
+    if (p->header.prev)
+        *p->header.prev = p->header.next;
+    if (p->header.next)
+        p->header.next->header.prev = p->header.prev;
+}
 
 Page *allocatePage(PersistentValueStorage *storage)
 {
@@ -78,19 +94,14 @@ Page *allocatePage(PersistentValueStorage *storage)
 
     p->header.engine = storage->engine;
     p->header.alloc = page;
-    p->header.next = reinterpret_cast<Page *>(storage->firstPage);
-    p->header.prev = reinterpret_cast<Page **>(&storage->firstPage);
     p->header.refCount = 0;
     p->header.freeList = 0;
-    if (p->header.next)
-        p->header.next->header.prev = &p->header.next;
+    insertInFront(storage, p);
     for (int i = 0; i < kEntriesPerPage - 1; ++i) {
         p->values[i].setEmpty(i + 1);
     }
     p->values[kEntriesPerPage - 1].setEmpty(-1);
 
-    storage->firstPage = p;
-
     return p;
 }
 
@@ -195,6 +206,12 @@ Value *PersistentValueStorage::allocate()
 
     Value *v = p->values + p->header.freeList;
     p->header.freeList = v->int_32();
+
+    if (p->header.freeList != -1 && p != firstPage) {
+        unlink(p);
+        insertInFront(this, p);
+    }
+
     ++p->header.refCount;
 
     v->setRawValue(Encode::undefined());
@@ -237,10 +254,7 @@ ExecutionEngine *PersistentValueStorage::getEngine(Value *v)
 void PersistentValueStorage::freePage(void *page)
 {
     Page *p = static_cast<Page *>(page);
-    if (p->header.prev)
-        *p->header.prev = p->header.next;
-    if (p->header.next)
-        p->header.next->header.prev = p->header.prev;
+    unlink(p);
     p->header.alloc.deallocate();
 }
 
diff --git a/src/qml/qml/qqmlimport.cpp b/src/qml/qml/qqmlimport.cpp
index 8b0bd9d6ec..b899e80470 100644
--- a/src/qml/qml/qqmlimport.cpp
+++ b/src/qml/qml/qqmlimport.cpp
@@ -2080,29 +2080,38 @@ bool QQmlImportDatabase::importStaticPlugin(QObject *instance, const QString &ba
     // Dynamic plugins are differentiated by their filepath. For static plugins we
     // don't have that information so we use their address as key instead.
     const QString uniquePluginID = QString::asprintf("%p", instance);
-    StringRegisteredPluginMap *plugins = qmlEnginePluginsWithRegisteredTypes();
-    QMutexLocker lock(&plugins->mutex);
+    {
+        StringRegisteredPluginMap *plugins = qmlEnginePluginsWithRegisteredTypes();
+        QMutexLocker lock(&plugins->mutex);
 
-    // Plugin types are global across all engines and should only be
-    // registered once. But each engine still needs to be initialized.
-    bool typesRegistered = plugins->contains(uniquePluginID);
-    bool engineInitialized = initializedPlugins.contains(uniquePluginID);
+        // Plugin types are global across all engines and should only be
+        // registered once. But each engine still needs to be initialized.
+        bool typesRegistered = plugins->contains(uniquePluginID);
 
-    if (typesRegistered) {
-        Q_ASSERT_X(plugins->value(uniquePluginID).uri == uri,
-                   "QQmlImportDatabase::importStaticPlugin",
-                   "Internal error: Static plugin imported previously with different uri");
-    } else {
-        RegisteredPlugin plugin;
-        plugin.uri = uri;
-        plugin.loader = 0;
-        plugins->insert(uniquePluginID, plugin);
+        if (typesRegistered) {
+            Q_ASSERT_X(plugins->value(uniquePluginID).uri == uri,
+                       "QQmlImportDatabase::importStaticPlugin",
+                       "Internal error: Static plugin imported previously with different uri");
+        } else {
+            RegisteredPlugin plugin;
+            plugin.uri = uri;
+            plugin.loader = 0;
+            plugins->insert(uniquePluginID, plugin);
 
-        if (!registerPluginTypes(instance, basePath, uri, typeNamespace, vmaj, errors))
-            return false;
+            if (!registerPluginTypes(instance, basePath, uri, typeNamespace, vmaj, errors))
+                return false;
+        }
+
+        // Release the lock on plugins early as we're done with the global part. Releasing the lock
+        // also allows other QML loader threads to acquire the lock while this thread is blocking
+        // in the initializeEngine call to the gui thread (which in turn may be busy waiting for
+        // other QML loader threads and thus not process the initializeEngine call).
     }
 
-    if (!engineInitialized) {
+    // The plugin's per-engine initialization does not need lock protection, as this function is
+    // only called from the engine specific loader thread and importDynamicPlugin as well as
+    // importStaticPlugin are the only places of access.
+    if (!initializedPlugins.contains(uniquePluginID)) {
         initializedPlugins.insert(uniquePluginID);
 
         if (QQmlExtensionInterface *eiface = qobject_cast<QQmlExtensionInterface *>(instance)) {
@@ -2124,68 +2133,77 @@ bool QQmlImportDatabase::importDynamicPlugin(const QString &filePath, const QStr
     QFileInfo fileInfo(filePath);
     const QString absoluteFilePath = fileInfo.absoluteFilePath();
 
+    QObject *instance = nullptr;
     bool engineInitialized = initializedPlugins.contains(absoluteFilePath);
-    StringRegisteredPluginMap *plugins = qmlEnginePluginsWithRegisteredTypes();
-    QMutexLocker lock(&plugins->mutex);
-    bool typesRegistered = plugins->contains(absoluteFilePath);
-
-    if (typesRegistered) {
-        Q_ASSERT_X(plugins->value(absoluteFilePath).uri == uri,
-                   "QQmlImportDatabase::importDynamicPlugin",
-                   "Internal error: Plugin imported previously with different uri");
-    }
-
-    if (!engineInitialized || !typesRegistered) {
-        if (!QQml_isFileCaseCorrect(absoluteFilePath)) {
-            if (errors) {
-                QQmlError error;
-                error.setDescription(tr("File name case mismatch for \"%1\"").arg(absoluteFilePath));
-                errors->prepend(error);
-            }
-            return false;
+    {
+        StringRegisteredPluginMap *plugins = qmlEnginePluginsWithRegisteredTypes();
+        QMutexLocker lock(&plugins->mutex);
+        bool typesRegistered = plugins->contains(absoluteFilePath);
+
+        if (typesRegistered) {
+            Q_ASSERT_X(plugins->value(absoluteFilePath).uri == uri,
+                       "QQmlImportDatabase::importDynamicPlugin",
+                       "Internal error: Plugin imported previously with different uri");
         }
 
-        QPluginLoader* loader = 0;
-        if (!typesRegistered) {
-            loader = new QPluginLoader(absoluteFilePath);
-
-            if (!loader->load()) {
+        if (!engineInitialized || !typesRegistered) {
+            if (!QQml_isFileCaseCorrect(absoluteFilePath)) {
                 if (errors) {
                     QQmlError error;
-                    error.setDescription(loader->errorString());
+                    error.setDescription(tr("File name case mismatch for \"%1\"").arg(absoluteFilePath));
                     errors->prepend(error);
                 }
-                delete loader;
                 return false;
             }
-        } else {
-            loader = plugins->value(absoluteFilePath).loader;
-        }
 
-       QObject *instance = loader->instance();
+            QPluginLoader* loader = 0;
+            if (!typesRegistered) {
+                loader = new QPluginLoader(absoluteFilePath);
 
-        if (!typesRegistered) {
-            RegisteredPlugin plugin;
-            plugin.uri = uri;
-            plugin.loader = loader;
-            plugins->insert(absoluteFilePath, plugin);
+                if (!loader->load()) {
+                    if (errors) {
+                        QQmlError error;
+                        error.setDescription(loader->errorString());
+                        errors->prepend(error);
+                    }
+                    delete loader;
+                    return false;
+                }
+            } else {
+                loader = plugins->value(absoluteFilePath).loader;
+            }
 
-            // Continue with shared code path for dynamic and static plugins:
-            if (!registerPluginTypes(instance, fileInfo.absolutePath(), uri, typeNamespace, vmaj, errors))
-                return false;
+            instance = loader->instance();
+
+            if (!typesRegistered) {
+                RegisteredPlugin plugin;
+                plugin.uri = uri;
+                plugin.loader = loader;
+                plugins->insert(absoluteFilePath, plugin);
+
+                // Continue with shared code path for dynamic and static plugins:
+                if (!registerPluginTypes(instance, fileInfo.absolutePath(), uri, typeNamespace, vmaj, errors))
+                    return false;
+            }
         }
 
-        if (!engineInitialized) {
-             // things on the engine (eg. adding new global objects) have to be done for every
-             // engine.
-             // XXX protect against double initialization
-             initializedPlugins.insert(absoluteFilePath);
-
-             if (QQmlExtensionInterface *eiface = qobject_cast<QQmlExtensionInterface *>(instance)) {
-                 QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
-                 ep->typeLoader.initializeEngine(eiface, uri.toUtf8().constData());
-             }
-         }
+    // Release the lock on plugins early as we're done with the global part. Releasing the lock
+    // also allows other QML loader threads to acquire the lock while this thread is blocking
+    // in the initializeEngine call to the gui thread (which in turn may be busy waiting for
+    // other QML loader threads and thus not process the initializeEngine call).
+    }
+
+
+    if (!engineInitialized) {
+        // The plugin's per-engine initialization does not need lock protection, as this function is
+        // only called from the engine specific loader thread and importDynamicPlugin as well as
+        // importStaticPlugin are the only places of access.
+        initializedPlugins.insert(absoluteFilePath);
+
+        if (QQmlExtensionInterface *eiface = qobject_cast<QQmlExtensionInterface *>(instance)) {
+            QQmlEnginePrivate *ep = QQmlEnginePrivate::get(engine);
+            ep->typeLoader.initializeEngine(eiface, uri.toUtf8().constData());
+        }
     }
 
     return true;
diff --git a/src/qml/qml/qqmlmetatype.cpp b/src/qml/qml/qqmlmetatype.cpp
index 1e4855f422..f368e6dae6 100644
--- a/src/qml/qml/qqmlmetatype.cpp
+++ b/src/qml/qml/qqmlmetatype.cpp
@@ -1569,6 +1569,12 @@ QString registrationTypeString(QQmlType::RegistrationType typeType)
 bool checkRegistration(QQmlType::RegistrationType typeType, QQmlMetaTypeData *data, const char *uri, const QString &typeName, int majorVersion = -1)
 {
     if (!typeName.isEmpty()) {
+        if (typeName.at(0).isLower()) {
+            QString failure(QCoreApplication::translate("qmlRegisterType", "Invalid QML %1 name \"%2\"; type names must begin with an uppercase letter"));
+            data->typeRegistrationFailures.append(failure.arg(registrationTypeString(typeType)).arg(typeName));
+            return false;
+        }
+
         int typeNameLen = typeName.length();
         for (int ii = 0; ii < typeNameLen; ++ii) {
             if (!(typeName.at(ii).isLetterOrNumber() || typeName.at(ii) == '_')) {
@@ -1814,6 +1820,9 @@ int QQmlPrivate::qmlregister(RegistrationType type, void *data)
     else
         return -1;
 
+    if (!dtype.isValid())
+        return -1;
+
     QMutexLocker lock(metaTypeDataLock());
     QQmlMetaTypeData *typeData = metaTypeData();
     typeData->undeletableTypes.insert(dtype);
diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp
index ce47ab9fa9..18c0cb8b91 100644
--- a/src/qml/qml/qqmlvaluetypewrapper.cpp
+++ b/src/qml/qml/qqmlvaluetypewrapper.cpp
@@ -98,6 +98,8 @@ void Heap::QQmlValueTypeWrapper::destroy()
         valueType->metaType.destruct(gadgetPtr);
         ::operator delete(gadgetPtr);
     }
+    if (_propertyCache)
+        _propertyCache->release();
     Object::destroy();
 }
 
diff --git a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
index 27c8e51381..2705ca5e34 100644
--- a/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
+++ b/src/quick/doc/src/concepts/modelviewsdata/cppmodels.qdoc
@@ -41,6 +41,10 @@ QObjectList or a \l QAbstractItemModel. The first three are useful for exposing
 simpler datasets, while QAbstractItemModel provides a more flexible solution for
 more complex models.
 
+For a video tutorial that takes you through the whole process of exposing a C++
+model to QML, see the
+\l {https://youtu.be/9BcAYDlpuT8}{Using C++ Models in QML Tutorial}.
+
 \section2 QStringList-based Model
 
 A model may be a simple \l QStringList, which provides the contents of the list
diff --git a/src/quick/items/qquickitemview.cpp b/src/quick/items/qquickitemview.cpp
index 856070634c..17a1d124ab 100644
--- a/src/quick/items/qquickitemview.cpp
+++ b/src/quick/items/qquickitemview.cpp
@@ -1894,6 +1894,9 @@ void QQuickItemViewPrivate::layout()
 
     inLayout = true;
 
+    // viewBounds contains bounds before any add/remove/move operation to the view
+    QRectF viewBounds(q->contentX(),  q->contentY(), q->width(), q->height());
+
     if (!isValid() && !visibleItems.count()) {
         clear();
         setPosition(contentStartOffset());
@@ -1960,7 +1963,6 @@ void QQuickItemViewPrivate::layout()
 
         prepareVisibleItemTransitions();
 
-        QRectF viewBounds(q->contentX(),  q->contentY(), q->width(), q->height());
         for (QList<FxViewItem*>::Iterator it = releasePendingTransition.begin();
              it != releasePendingTransition.end(); ) {
             FxViewItem *item = *it;
diff --git a/src/quick/items/qquickloader.cpp b/src/quick/items/qquickloader.cpp
index d5601292b7..c8f7d8440e 100644
--- a/src/quick/items/qquickloader.cpp
+++ b/src/quick/items/qquickloader.cpp
@@ -686,6 +686,13 @@ void QQuickLoaderPrivate::incubatorStateChanged(QQmlIncubator::Status status)
     if (status == QQmlIncubator::Ready) {
         object = incubator->object();
         item = qmlobject_cast<QQuickItem*>(object);
+        if (!item) {
+            QQuickWindow *window = qmlobject_cast<QQuickWindow*>(object);
+            if (window) {
+                qCDebug(lcTransient) << window << "is transient for" << q->window();
+                window->setTransientParent(q->window());
+            }
+        }
         emit q->itemChanged();
         initResize();
         incubator->clear();
@@ -830,6 +837,18 @@ void QQuickLoader::componentComplete()
     }
 }
 
+void QQuickLoader::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
+{
+    if (change == ItemSceneChange) {
+        QQuickWindow *loadedWindow = qmlobject_cast<QQuickWindow *>(item());
+        if (loadedWindow) {
+            qCDebug(lcTransient) << loadedWindow << "is transient for" << value.window;
+            loadedWindow->setTransientParent(value.window);
+        }
+    }
+    QQuickItem::itemChange(change, value);
+}
+
 /*!
     \qmlsignal QtQuick::Loader::loaded()
 
diff --git a/src/quick/items/qquickloader_p.h b/src/quick/items/qquickloader_p.h
index db171dcd1e..8f0a9980b9 100644
--- a/src/quick/items/qquickloader_p.h
+++ b/src/quick/items/qquickloader_p.h
@@ -107,6 +107,7 @@ Q_SIGNALS:
 protected:
     void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) Q_DECL_OVERRIDE;
     void componentComplete() Q_DECL_OVERRIDE;
+    void itemChange(ItemChange change, const ItemChangeData &value) override;
 
 private:
     void setSource(const QUrl &sourceUrl, bool needsClear);
diff --git a/src/quick/items/qquicktextinput.cpp b/src/quick/items/qquicktextinput.cpp
index d516b6f30c..45537a3507 100644
--- a/src/quick/items/qquicktextinput.cpp
+++ b/src/quick/items/qquicktextinput.cpp
@@ -1108,7 +1108,8 @@ void QQuickTextInputPrivate::checkIsValid()
     Q_Q(QQuickTextInput);
 
     ValidatorState state = hasAcceptableInput(m_text);
-    m_validInput = state != InvalidInput;
+    if (!m_maskData)
+        m_validInput = state != InvalidInput;
     if (state != AcceptableInput) {
         if (m_acceptableInput) {
             m_acceptableInput = false;
@@ -3561,11 +3562,15 @@ bool QQuickTextInputPrivate::finishChange(int validateFromState, bool update, bo
 #if QT_CONFIG(validator)
         if (m_validator) {
             QString textCopy = m_text;
+            if (m_maskData)
+                textCopy = maskString(0, m_text, true);
             int cursorCopy = m_cursor;
             QValidator::State state = m_validator->validate(textCopy, cursorCopy);
+            if (m_maskData)
+                textCopy = m_text;
             m_validInput = state != QValidator::Invalid;
             m_acceptableInput = state == QValidator::Acceptable;
-            if (m_validInput) {
+            if (m_validInput && !m_maskData) {
                 if (m_text != textCopy) {
                     internalSetText(textCopy, cursorCopy);
                     return true;
@@ -3574,31 +3579,8 @@ bool QQuickTextInputPrivate::finishChange(int validateFromState, bool update, bo
             }
         }
 #endif
-
-        if (m_maskData) {
-            m_validInput = true;
-            if (m_text.length() != m_maxLength) {
-                m_validInput = false;
-                m_acceptableInput = false;
-            } else {
-                for (int i = 0; i < m_maxLength; ++i) {
-                    if (m_maskData[i].separator) {
-                        if (m_text.at(i) != m_maskData[i].maskChar) {
-                            m_validInput = false;
-                            m_acceptableInput = false;
-                            break;
-                        }
-                    } else {
-                        if (!isValidInput(m_text.at(i), m_maskData[i].maskChar)) {
-                            m_acceptableInput = false;
-                            if (m_text.at(i) != m_blank)
-                                m_validInput = false;
-                            break;
-                        }
-                    }
-                }
-            }
-        }
+        if (m_maskData)
+            checkIsValid();
 
         if (validateFromState >= 0 && wasValidInput && !m_validInput) {
             if (m_transactions.count())
diff --git a/src/quick/items/qquickwindowmodule.cpp b/src/quick/items/qquickwindowmodule.cpp
index 6165ce1ba1..c1e4bce12f 100644
--- a/src/quick/items/qquickwindowmodule.cpp
+++ b/src/quick/items/qquickwindowmodule.cpp
@@ -123,7 +123,13 @@ void QQuickWindowQmlImpl::componentComplete()
 {
     Q_D(QQuickWindowQmlImpl);
     d->complete = true;
-    if (transientParent() && !transientParent()->isVisible()) {
+    QQuickItem *itemParent = qmlobject_cast<QQuickItem *>(QObject::parent());
+    if (itemParent && !itemParent->window()) {
+        qCDebug(lcTransient) << "window" << title() << "has invisible Item parent" << itemParent << "transientParent"
+                             << transientParent() << "declared visibility" << d->visibility << "; delaying show";
+        connect(itemParent, &QQuickItem::windowChanged, this,
+                &QQuickWindowQmlImpl::setWindowVisibility, Qt::QueuedConnection);
+    } else if (transientParent() && !transientParent()->isVisible()) {
         connect(transientParent(), &QQuickWindow::visibleChanged, this,
                 &QQuickWindowQmlImpl::setWindowVisibility, Qt::QueuedConnection);
     } else {
@@ -137,9 +143,10 @@ void QQuickWindowQmlImpl::setWindowVisibility()
     if (transientParent() && !transientParent()->isVisible())
         return;
 
-    if (sender()) {
-        disconnect(transientParent(), &QWindow::visibleChanged, this,
-                   &QQuickWindowQmlImpl::setWindowVisibility);
+    if (QQuickItem *senderItem = qmlobject_cast<QQuickItem *>(sender())) {
+        disconnect(senderItem, &QQuickItem::windowChanged, this, &QQuickWindowQmlImpl::setWindowVisibility);
+    } else if (sender()) {
+        disconnect(transientParent(), &QWindow::visibleChanged, this, &QQuickWindowQmlImpl::setWindowVisibility);
     }
 
     // We have deferred window creation until we have the full picture of what
diff --git a/tests/auto/qml/qmlcachegen/tst_qmlcachegen.cpp b/tests/auto/qml/qmlcachegen/tst_qmlcachegen.cpp
index 7e81df93b9..d8afcd6946 100644
--- a/tests/auto/qml/qmlcachegen/tst_qmlcachegen.cpp
+++ b/tests/auto/qml/qmlcachegen/tst_qmlcachegen.cpp
@@ -33,6 +33,7 @@
 #include <QProcess>
 #include <QLibraryInfo>
 #include <QSysInfo>
+#include <private/qqmlcomponent_p.h>
 
 class tst_qmlcachegen: public QObject
 {
@@ -115,6 +116,16 @@ void tst_qmlcachegen::loadGeneratedFile()
 
     const QString cacheFilePath = testFilePath + QLatin1Char('c');
     QVERIFY(QFile::exists(cacheFilePath));
+
+    {
+        QFile cache(cacheFilePath);
+        QVERIFY(cache.open(QIODevice::ReadOnly));
+        const QV4::CompiledData::Unit *cacheUnit = reinterpret_cast<const QV4::CompiledData::Unit *>(cache.map(/*offset*/0, sizeof(QV4::CompiledData::Unit)));
+        QVERIFY(cacheUnit);
+        QVERIFY(cacheUnit->flags & QV4::CompiledData::Unit::StaticData);
+        QVERIFY(cacheUnit->flags & QV4::CompiledData::Unit::PendingTypeCompilation);
+    }
+
     QVERIFY(QFile::remove(testFilePath));
 
     QQmlEngine engine;
@@ -122,6 +133,13 @@ void tst_qmlcachegen::loadGeneratedFile()
     QScopedPointer<QObject> obj(component.create());
     QVERIFY(!obj.isNull());
     QCOMPARE(obj->property("value").toInt(), 42);
+
+    auto componentPrivate = QQmlComponentPrivate::get(&component);
+    QVERIFY(componentPrivate);
+    auto compilationUnit = componentPrivate->compilationUnit;
+    QVERIFY(compilationUnit);
+    QVERIFY(compilationUnit->data);
+    QVERIFY(!(compilationUnit->data->flags & QV4::CompiledData::Unit::StaticData));
 }
 
 void tst_qmlcachegen::translationExpressionSupport()
diff --git a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
index 72e1a2915d..03d53b755d 100644
--- a/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
+++ b/tests/auto/qml/qqmllanguage/tst_qqmllanguage.cpp
@@ -279,6 +279,8 @@ private slots:
 
     void accessDeletedObject();
 
+    void lowercaseTypeNames();
+
 private:
     QQmlEngine engine;
     QStringList defaultImportPathList;
@@ -4903,6 +4905,12 @@ void tst_qqmllanguage::accessDeletedObject()
     QVERIFY(!o.isNull());
 }
 
+void tst_qqmllanguage::lowercaseTypeNames()
+{
+    QCOMPARE(qmlRegisterType<QObject>("Test", 1, 0, "lowerCaseTypeName"), -1);
+    QCOMPARE(qmlRegisterSingletonType<QObject>("Test", 1, 0, "lowerCaseTypeName", nullptr), -1);
+}
+
 QTEST_MAIN(tst_qqmllanguage)
 
 #include "tst_qqmllanguage.moc"
diff --git a/tests/auto/qml/qqmlmoduleplugin/moduleWithStaticPlugin/qmldir b/tests/auto/qml/qqmlmoduleplugin/moduleWithStaticPlugin/qmldir
new file mode 100644
index 0000000000..104c4bf673
--- /dev/null
+++ b/tests/auto/qml/qqmlmoduleplugin/moduleWithStaticPlugin/qmldir
@@ -0,0 +1,2 @@
+module moduleWithStaticPlugin
+plugin secondStaticPlugin
diff --git a/tests/auto/qml/qqmlmoduleplugin/moduleWithWaitingPlugin/qmldir b/tests/auto/qml/qqmlmoduleplugin/moduleWithWaitingPlugin/qmldir
new file mode 100644
index 0000000000..45a02b2ffe
--- /dev/null
+++ b/tests/auto/qml/qqmlmoduleplugin/moduleWithWaitingPlugin/qmldir
@@ -0,0 +1,2 @@
+module moduleWithWaitingPlugin
+plugin pluginThatWaits
diff --git a/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.cpp b/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.cpp
index 8600e1e8ab..9abff7b2f6 100644
--- a/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.cpp
+++ b/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.cpp
@@ -29,6 +29,9 @@
 #include <qdir.h>
 #include <QtQml/qqmlengine.h>
 #include <QtQml/qqmlcomponent.h>
+#include <QtQml/qqmlextensionplugin.h>
+#include <QtCore/qjsondocument.h>
+#include <QtCore/qjsonarray.h>
 #include <QDebug>
 
 #if defined(Q_OS_MAC)
@@ -73,12 +76,80 @@ private slots:
     void importsChildPlugin();
     void importsChildPlugin2();
     void importsChildPlugin21();
+    void parallelPluginImport();
 
 private:
     QString m_importsDirectory;
     QString m_dataImportsDirectory;
 };
 
+class PluginThatWaits : public QQmlExtensionPlugin
+{
+public:
+    static QByteArray metaData;
+
+    static QMutex initializeEngineEntered;
+    static QWaitCondition waitingForInitializeEngineEntry;
+    static QMutex leavingInitializeEngine;
+    static QWaitCondition waitingForInitializeEngineLeave;
+
+    void registerTypes(const char *uri) override
+    {
+        qmlRegisterModule(uri, 1, 0);
+    }
+
+    void initializeEngine(QQmlEngine *engine, const char *uri) override
+    {
+        initializeEngineEntered.lock();
+        leavingInitializeEngine.lock();
+        waitingForInitializeEngineEntry.wakeOne();
+        initializeEngineEntered.unlock();
+        waitingForInitializeEngineLeave.wait(&leavingInitializeEngine);
+        leavingInitializeEngine.unlock();
+    }
+};
+QByteArray PluginThatWaits::metaData;
+QMutex PluginThatWaits::initializeEngineEntered;
+QWaitCondition PluginThatWaits::waitingForInitializeEngineEntry;
+QMutex PluginThatWaits::leavingInitializeEngine;
+QWaitCondition PluginThatWaits::waitingForInitializeEngineLeave;
+
+class SecondStaticPlugin : public QQmlExtensionPlugin
+{
+public:
+    static QByteArray metaData;
+
+    void registerTypes(const char *uri) override
+    {
+        qmlRegisterModule(uri, 1, 0);
+    }
+};
+QByteArray SecondStaticPlugin::metaData;
+
+template <typename PluginType>
+void registerStaticPlugin(const char *uri)
+{
+    QStaticPlugin plugin;
+    plugin.instance = []() {
+        static PluginType plugin;
+        return static_cast<QObject*>(&plugin);
+    };
+
+    QJsonObject md;
+    md.insert(QStringLiteral("IID"), QQmlExtensionInterface_iid);
+    QJsonArray uris;
+    uris.append(uri);
+    md.insert(QStringLiteral("uri"), uris);
+
+    PluginType::metaData.append(QLatin1String("QTMETADATA  "));
+    PluginType::metaData.append(QJsonDocument(md).toBinaryData());
+
+    plugin.rawMetaData = []() {
+        return PluginType::metaData.constData();
+    };
+    qRegisterStaticPluginFunction(plugin);
+};
+
 void tst_qqmlmoduleplugin::initTestCase()
 {
     QQmlDataTest::initTestCase();
@@ -88,6 +159,9 @@ void tst_qqmlmoduleplugin::initTestCase()
     m_dataImportsDirectory = directory() + QStringLiteral("/imports");
     QVERIFY2(QFileInfo(m_dataImportsDirectory).isDir(),
              qPrintable(QString::fromLatin1("Imports directory '%1' does not exist.").arg(m_dataImportsDirectory)));
+
+    registerStaticPlugin<PluginThatWaits>("moduleWithWaitingPlugin");
+    registerStaticPlugin<SecondStaticPlugin>("moduleWithStaticPlugin");
 }
 
 #define VERIFY_ERRORS(errorfile) \
@@ -635,6 +709,51 @@ void tst_qqmlmoduleplugin::importsChildPlugin21()
     delete object;
 }
 
+void tst_qqmlmoduleplugin::parallelPluginImport()
+{
+    QMutexLocker locker(&PluginThatWaits::initializeEngineEntered);
+
+    QThread worker;
+    QObject::connect(&worker, &QThread::started, [&worker](){
+        // Engines in separate threads are tricky, but as long as we do not create a graphical
+        // object and move objects created by the engines across thread boundaries, this is safe.
+        // At the same time this allows us to place the engine's loader thread into the position
+        // where, without the fix for this bug, the global lock is acquired.
+        QQmlEngine engineInThread;
+
+        QQmlComponent component(&engineInThread);
+        component.setData("import moduleWithWaitingPlugin 1.0\nimport QtQml 2.0\nQtObject {}",
+                          QUrl());
+
+        QScopedPointer<QObject> obj(component.create());
+        QVERIFY(!obj.isNull());
+
+        worker.quit();
+    });
+    worker.start();
+
+    PluginThatWaits::waitingForInitializeEngineEntry.wait(&PluginThatWaits::initializeEngineEntered);
+
+    {
+        // After acquiring this lock, the engine in the other thread as well as its type loader
+        // thread are blocked. However they should not hold the global plugin lock
+        // qmlEnginePluginsWithRegisteredTypes()->mutex in qqmllimports.cpp, allowing for the load
+        // of a component in a different engine with its own plugin to proceed.
+        QMutexLocker continuationLock(&PluginThatWaits::leavingInitializeEngine);
+
+        QQmlEngine secondEngine;
+        QQmlComponent secondComponent(&secondEngine);
+        secondComponent.setData("import moduleWithStaticPlugin 1.0\nimport QtQml 2.0\nQtObject {}",
+                                QUrl());
+        QScopedPointer<QObject> o(secondComponent.create());
+        QVERIFY(!o.isNull());
+
+        PluginThatWaits::waitingForInitializeEngineLeave.wakeOne();
+    }
+
+    worker.wait();
+}
+
 QTEST_MAIN(tst_qqmlmoduleplugin)
 
 #include "tst_qqmlmoduleplugin.moc"
diff --git a/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.pro b/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.pro
index 43bd112415..118ca26ee9 100644
--- a/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.pro
+++ b/tests/auto/qml/qqmlmoduleplugin/tst_qqmlmoduleplugin.pro
@@ -10,4 +10,12 @@ include (../../shared/util.pri)
 
 TESTDATA = data/* imports/* $$OUT_PWD/imports/*
 
+waitingPlugin.files = moduleWithWaitingPlugin
+waitingPlugin.prefix = /qt-project.org/imports/
+RESOURCES += waitingPlugin
+
+staticPlugin.files = moduleWithStaticPlugin
+staticPlugin.prefix = /qt-project.org/imports/
+RESOURCES += staticPlugin
+
 QT += core-private gui-private qml-private network testlib
diff --git a/tests/auto/quick/qquickloader/data/itemLoaderItemWindow.qml b/tests/auto/quick/qquickloader/data/itemLoaderItemWindow.qml
new file mode 100644
index 0000000000..d4c5daecab
--- /dev/null
+++ b/tests/auto/quick/qquickloader/data/itemLoaderItemWindow.qml
@@ -0,0 +1,27 @@
+import QtQuick 2.0
+import QtQuick.Window 2.1
+
+Item {
+    width: 400
+    height: 400
+    objectName: "root Item"
+
+    Loader {
+        sourceComponent: Rectangle {
+            objectName: "yellow rectangle"
+            x: 50; y: 50; width: 300; height: 300
+            color: "yellow"
+            Window {
+                objectName: "red transient Window"
+                width: 100
+                height: 100
+                visible: true // makes it harder, because it wants to become visible before root has a window
+                color: "red"
+                title: "red"
+                flags: Qt.Dialog
+                onVisibilityChanged: console.log("visibility " + visibility)
+                onVisibleChanged: console.log("visible " + visible)
+            }
+        }
+    }
+}
diff --git a/tests/auto/quick/qquickloader/data/itemLoaderWindow.qml b/tests/auto/quick/qquickloader/data/itemLoaderWindow.qml
new file mode 100644
index 0000000000..69421448e0
--- /dev/null
+++ b/tests/auto/quick/qquickloader/data/itemLoaderWindow.qml
@@ -0,0 +1,22 @@
+import QtQuick 2.0
+import QtQuick.Window 2.1
+
+Item {
+    width: 400
+    height: 400
+    objectName: "root Item"
+
+    Loader {
+        sourceComponent: Window {
+            objectName: "red transient Window"
+            width: 100
+            height: 100
+            visible: true // makes it harder, because it wants to become visible before root has a window
+            color: "red"
+            title: "red"
+            flags: Qt.Dialog
+            onVisibilityChanged: console.log("visibility " + visibility)
+            onVisibleChanged: console.log("visible " + visible)
+        }
+    }
+}
diff --git a/tests/auto/quick/qquickloader/tst_qquickloader.cpp b/tests/auto/quick/qquickloader/tst_qquickloader.cpp
index e557b592ee..65493f52e2 100644
--- a/tests/auto/quick/qquickloader/tst_qquickloader.cpp
+++ b/tests/auto/quick/qquickloader/tst_qquickloader.cpp
@@ -32,11 +32,15 @@
 #include <QtQml/qqmlengine.h>
 #include <QtQml/qqmlcomponent.h>
 #include <QtQml/qqmlincubator.h>
+#include <QtQuick/qquickview.h>
 #include <private/qquickloader_p.h>
+#include <private/qquickwindowmodule_p.h>
 #include "testhttpserver.h"
 #include "../../shared/util.h"
 #include "../shared/geometrytestutil.h"
 
+Q_LOGGING_CATEGORY(lcTests, "qt.quick.tests")
+
 class SlowComponent : public QQmlComponent
 {
     Q_OBJECT
@@ -112,6 +116,8 @@ private slots:
     void parented();
     void sizeBound();
     void QTBUG_30183();
+    void transientWindow();
+    void nestedTransientWindow();
 
     void sourceComponentGarbageCollection();
 
@@ -1159,6 +1165,86 @@ void tst_QQuickLoader::QTBUG_30183()
     QCOMPARE(rect->height(), 120.0);
 }
 
+void tst_QQuickLoader::transientWindow() // QTBUG-52944
+{
+    QQuickView view;
+    view.setSource(testFileUrl("itemLoaderWindow.qml"));
+    QQuickItem *root = qobject_cast<QQuickItem*>(view.rootObject());
+    QVERIFY(root);
+    QQuickLoader *loader = root->findChild<QQuickLoader *>();
+    QVERIFY(loader);
+    QTRY_COMPARE(loader->status(), QQuickLoader::Ready);
+    QQuickWindowQmlImpl *loadedWindow = qobject_cast<QQuickWindowQmlImpl *>(loader->item());
+    QVERIFY(loadedWindow);
+    QCOMPARE(loadedWindow->visibility(), QWindow::Hidden);
+
+    QElapsedTimer timer;
+    qint64 viewVisibleTime = -1;
+    qint64 loadedWindowVisibleTime = -1;
+    connect(&view, &QWindow::visibleChanged,
+            [&viewVisibleTime, &timer]() { viewVisibleTime = timer.elapsed(); } );
+    connect(loadedWindow, &QQuickWindowQmlImpl::visibilityChanged,
+            [&loadedWindowVisibleTime, &timer]() { loadedWindowVisibleTime = timer.elapsed(); } );
+    timer.start();
+    view.show();
+
+    QTest::qWaitForWindowExposed(&view);
+    QTRY_VERIFY(loadedWindowVisibleTime >= 0);
+    QVERIFY(viewVisibleTime >= 0);
+
+    // now that we're sure they are both visible, which one became visible first?
+    qCDebug(lcTests) << "transient Window became visible" << (loadedWindowVisibleTime - viewVisibleTime) << "ms after the root Item";
+    QVERIFY((loadedWindowVisibleTime - viewVisibleTime) >= 0);
+
+    QWindowList windows = QGuiApplication::topLevelWindows();
+    QTRY_COMPARE(windows.size(), 2);
+
+    // TODO Ideally we would now close the outer window and make sure the transient window closes too.
+    // It works during manual testing because of QWindowPrivate::maybeQuitOnLastWindowClosed()
+    // but quitting an autotest doesn't make sense.
+}
+
+void tst_QQuickLoader::nestedTransientWindow() // QTBUG-52944
+{
+    QQuickView view;
+    view.setSource(testFileUrl("itemLoaderItemWindow.qml"));
+    QQuickItem *root = qobject_cast<QQuickItem*>(view.rootObject());
+    QVERIFY(root);
+    QQuickLoader *loader = root->findChild<QQuickLoader *>();
+    QVERIFY(loader);
+    QTRY_COMPARE(loader->status(), QQuickLoader::Ready);
+    QQuickItem *loadedItem = qobject_cast<QQuickItem *>(loader->item());
+    QVERIFY(loadedItem);
+    QQuickWindowQmlImpl *loadedWindow = loadedItem->findChild<QQuickWindowQmlImpl *>();
+    QVERIFY(loadedWindow);
+    QCOMPARE(loadedWindow->visibility(), QWindow::Hidden);
+
+    QElapsedTimer timer;
+    qint64 viewVisibleTime = -1;
+    qint64 loadedWindowVisibleTime = -1;
+    connect(&view, &QWindow::visibleChanged,
+            [&viewVisibleTime, &timer]() { viewVisibleTime = timer.elapsed(); } );
+    connect(loadedWindow, &QQuickWindowQmlImpl::visibilityChanged,
+            [&loadedWindowVisibleTime, &timer]() { loadedWindowVisibleTime = timer.elapsed(); } );
+    timer.start();
+    view.show();
+
+    QTest::qWaitForWindowExposed(&view);
+    QTRY_VERIFY(loadedWindowVisibleTime >= 0);
+    QVERIFY(viewVisibleTime >= 0);
+
+    // now that we're sure they are both visible, which one became visible first?
+    qCDebug(lcTests) << "transient Window became visible" << (loadedWindowVisibleTime - viewVisibleTime) << "ms after the root Item";
+    QVERIFY((loadedWindowVisibleTime - viewVisibleTime) >= 0);
+
+    QWindowList windows = QGuiApplication::topLevelWindows();
+    QTRY_COMPARE(windows.size(), 2);
+
+    // TODO Ideally we would now close the outer window and make sure the transient window closes too.
+    // It works during manual testing because of QWindowPrivate::maybeQuitOnLastWindowClosed()
+    // but quitting an autotest doesn't make sense.
+}
+
 void tst_QQuickLoader::sourceComponentGarbageCollection()
 {
     QQmlEngine engine;
diff --git a/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp b/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp
index 9b526f80c5..5b2c585a92 100644
--- a/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp
+++ b/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp
@@ -6143,9 +6143,17 @@ void tst_qquicktextinput::keypress_inputMask_withValidator_data()
         KeyList keys;
         // inserting '1111.11' then two backspaces
         keys << Qt::Key_Home << "1111.11" << Qt::Key_Backspace << Qt::Key_Backspace;
-        QTest::newRow("backspaceWithRegExp") << QString("9999.99;_") << 0.0 << 0.0 << 0
+        QTest::newRow("backspaceWithRegExp") << QString("9999;_") << 0.0 << 0.0 << 0
                                              << QString("/^[-]?((\\.\\d+)|(\\d+(\\.\\d+)?))$/")
-                                             << keys << QString("1111.") << QString("1111.__");
+                                             << keys << QString("11") << QString("11__");
+    }
+    {
+        KeyList keys;
+        // inserting '99' - QTBUG-64616
+        keys << Qt::Key_Home << "99";
+        QTest::newRow("invalidTextWithRegExp") << QString("X9;_") << 0.0 << 0.0 << 0
+                                               << QString("/[+-][0+9]/")
+                                               << keys << QString("") << QString("__");
     }
 }