Merge remote-tracking branch 'origin/5.12' into 5.13

 Conflicts:
	src/corelib/tools/qlocale.qdoc
	tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp

Done-with: Edward Welbourne <edward.welbourne@qt.io>
Done-with: Volker Hilsheimer <volker.hilsheimer@qt.io>
Change-Id: I88e0757b2d020f0a244714c87844631df4b3fd13

5 files changed, 334 insertions, 101 deletions

diff --git a/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp b/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
index 714c96b5e5..a92b4bd1cb 100644
--- a/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
+++ b/tests/auto/corelib/io/qfileinfo/tst_qfileinfo.cpp
@@ -1559,6 +1559,16 @@ void tst_QFileInfo::ntfsJunctionPointsAndSymlinks_data()
             << NtfsTestResource(NtfsTestResource::SymLink, relToRelSymlink, relToRelTarget)
             << relToRelSymlink << true << QDir::fromNativeSeparators(absTarget) << target.canonicalFilePath();
     }
+    {
+        // Symlink to UNC share
+        pwd.mkdir("unc");
+        QString errorMessage;
+        QString uncTarget = QStringLiteral("//") + QtNetworkSettings::winServerName() + "/testshare";
+        QString uncSymlink = QDir::toNativeSeparators(pwd.absolutePath().append("\\unc\\link_to_unc"));
+        QTest::newRow("UNC symlink")
+            << NtfsTestResource(NtfsTestResource::SymLink, uncSymlink, uncTarget)
+            << QDir::fromNativeSeparators(uncSymlink) << true << QDir::fromNativeSeparators(uncTarget) << uncTarget;
+    }
 
     //Junctions
     QString target = "target";
@@ -1630,7 +1640,7 @@ void tst_QFileInfo::ntfsJunctionPointsAndSymlinks()
     // Ensure that junctions, mountpoints are removed. If this fails, do not remove
     // temporary directory to prevent it from trashing the system.
     if (fi.isDir()) {
-        if (!QDir().rmdir(fi.fileName())) {
+        if (!QDir().rmdir(fi.filePath())) {
             qWarning("Unable to remove NTFS junction '%s'', keeping '%s'.",
                      qPrintable(fi.fileName()), qPrintable(QDir::toNativeSeparators(m_dir.path())));
             m_dir.setAutoRemove(false);
diff --git a/tests/auto/corelib/kernel/qmetaobject/qmetaobject.pro b/tests/auto/corelib/kernel/qmetaobject/qmetaobject.pro
index e7e5a03a86..980c247ab5 100644
--- a/tests/auto/corelib/kernel/qmetaobject/qmetaobject.pro
+++ b/tests/auto/corelib/kernel/qmetaobject/qmetaobject.pro
@@ -1,4 +1,5 @@
 CONFIG += testcase
+qtConfig(c++14): CONFIG += c++14
 TARGET = tst_qmetaobject
 QT = core-private testlib
 SOURCES = tst_qmetaobject.cpp
diff --git a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
index 350ed24c28..89a06b358e 100644
--- a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
+++ b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
@@ -816,6 +816,15 @@ void tst_QMetaObject::invokePointer()
         QCOMPARE(obj.slotResult, QString("sl1:bubu"));
     }
     QCOMPARE(countedStructObjectsCount, 0);
+#ifdef __cpp_init_captures
+    {
+        CountedStruct str;
+        std::unique_ptr<int> ptr( new int );
+        QVERIFY(QMetaObject::invokeMethod(&obj, [str, &t1, &obj, p = std::move(ptr)]() { obj.sl1(t1); }));
+        QCOMPARE(obj.slotResult, QString("sl1:1"));
+    }
+    QCOMPARE(countedStructObjectsCount, 0);
+#endif
 }
 
 void tst_QMetaObject::invokeQueuedMetaMember()
@@ -1121,6 +1130,15 @@ void tst_QMetaObject::invokeBlockingQueuedPointer()
         QCOMPARE(exp, QString("yessir"));
         QCOMPARE(obj.slotResult, QString("sl1:bubu"));
     }
+#ifdef __cpp_init_captures
+    {
+        std::unique_ptr<int> ptr(new int);
+        QVERIFY(QMetaObject::invokeMethod(&obj,
+                                          [&obj, p = std::move(ptr)]() { return obj.sl1("hehe"); },
+                                          Qt::BlockingQueuedConnection));
+        QCOMPARE(obj.slotResult, QString("sl1:hehe"));
+    }
+#endif
     QVERIFY(QMetaObject::invokeMethod(&obj, [&](){obj.moveToThread(QThread::currentThread());}, Qt::BlockingQueuedConnection));
     t.quit();
     QVERIFY(t.wait());
diff --git a/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp b/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp
index 82197f815e..f8bb0c3851 100644
--- a/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp
+++ b/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp
@@ -35,11 +35,13 @@
 
 namespace
 {
-    QShaderFormat createFormat(QShaderFormat::Api api, int majorVersion, int minorVersion)
+    QShaderFormat createFormat(QShaderFormat::Api api, int majorVersion, int minorVersion,
+                               QShaderFormat::ShaderType shaderType= QShaderFormat::Fragment)
     {
         auto format = QShaderFormat();
         format.setApi(api);
         format.setVersion(QVersionNumber(majorVersion, minorVersion));
+        format.setShaderType(shaderType);
         return format;
     }
 
@@ -74,7 +76,7 @@ namespace
         return edge;
     }
 
-    QShaderGraph createGraph()
+    QShaderGraph createFragmentShaderGraph()
     {
         const auto openGLES2 = createFormat(QShaderFormat::OpenGLES, 2, 0);
         const auto openGL3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0);
@@ -194,6 +196,7 @@ private slots:
     void shouldProcessLanguageQualifierAndTypeEnums_data();
     void shouldProcessLanguageQualifierAndTypeEnums();
     void shouldGenerateDifferentCodeDependingOnActiveLayers();
+    void shouldUseGlobalVariableRatherThanTemporaries();
 };
 
 void tst_QShaderGenerator::shouldHaveDefaultState()
@@ -213,7 +216,7 @@ void tst_QShaderGenerator::shouldGenerateShaderCode_data()
     QTest::addColumn<QShaderFormat>("format");
     QTest::addColumn<QByteArray>("expectedCode");
 
-    const auto graph = createGraph();
+    const auto graph = createFragmentShaderGraph();
 
     const auto openGLES2 = createFormat(QShaderFormat::OpenGLES, 2, 0);
     const auto openGL3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0);
@@ -234,14 +237,9 @@ void tst_QShaderGenerator::shouldGenerateShaderCode_data()
                                           << ""
                                           << "void main()"
                                           << "{"
-                                          << "    highp vec2 v2 = texCoord;"
-                                          << "    sampler2D v1 = texture;"
-                                          << "    highp float v3 = lightIntensity;"
-                                          << "    highp vec4 v5 = texture2D(v1, v2);"
-                                          << "    highp vec3 v0 = worldPosition;"
-                                          << "    highp float v4 = exposure;"
-                                          << "    highp vec4 v6 = lightModel(v5, v0, v3);"
-                                          << "    highp vec4 v7 = v6 * pow(2.0, v4);"
+                                          << "    highp vec4 v5 = texture2D(texture, texCoord);"
+                                          << "    highp vec4 v6 = lightModel(v5, worldPosition, lightIntensity);"
+                                          << "    highp vec4 v7 = v6 * pow(2.0, exposure);"
                                           << "    gl_fragColor = v7;"
                                           << "}"
                                           << "";
@@ -256,14 +254,9 @@ void tst_QShaderGenerator::shouldGenerateShaderCode_data()
                                           << ""
                                           << "void main()"
                                           << "{"
-                                          << "    vec2 v2 = texCoord;"
-                                          << "    sampler2D v1 = texture;"
-                                          << "    float v3 = lightIntensity;"
-                                          << "    vec4 v5 = texture2D(v1, v2);"
-                                          << "    vec3 v0 = worldPosition;"
-                                          << "    float v4 = exposure;"
-                                          << "    vec4 v6 = lightModel(v5, v0, v3);"
-                                          << "    vec4 v7 = v6 * pow(2.0, v4);"
+                                          << "    vec4 v5 = texture2D(texture, texCoord);"
+                                          << "    vec4 v6 = lightModel(v5, worldPosition, lightIntensity);"
+                                          << "    vec4 v7 = v6 * pow(2.0, exposure);"
                                           << "    fragColor = v7;"
                                           << "}"
                                           << "";
@@ -580,120 +573,190 @@ void tst_QShaderGenerator::shouldProcessLanguageQualifierAndTypeEnums_data()
     QTest::addColumn<QShaderFormat>("format");
     QTest::addColumn<QByteArray>("expectedCode");
 
-    const auto es2 = createFormat(QShaderFormat::OpenGLES, 2, 0);
-    const auto es3 = createFormat(QShaderFormat::OpenGLES, 3, 0);
-    const auto gl2 = createFormat(QShaderFormat::OpenGLNoProfile, 2, 0);
-    const auto gl3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0);
-    const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0);
-
-    const auto qualifierEnum = QMetaEnum::fromType<QShaderLanguage::StorageQualifier>();
-    const auto typeEnum = QMetaEnum::fromType<QShaderLanguage::VariableType>();
-
-    for (int qualifierIndex = 0; qualifierIndex < qualifierEnum.keyCount(); qualifierIndex++) {
-        const auto qualifierName = qualifierEnum.key(qualifierIndex);
-        const auto qualifierValue = static_cast<QShaderLanguage::StorageQualifier>(qualifierEnum.value(qualifierIndex));
+    {
+        const auto es2 = createFormat(QShaderFormat::OpenGLES, 2, 0);
+        const auto es3 = createFormat(QShaderFormat::OpenGLES, 3, 0);
+        const auto gl2 = createFormat(QShaderFormat::OpenGLNoProfile, 2, 0);
+        const auto gl3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0);
+        const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0);
+
+        const auto qualifierEnum = QMetaEnum::fromType<QShaderLanguage::StorageQualifier>();
+        const auto typeEnum = QMetaEnum::fromType<QShaderLanguage::VariableType>();
+
+        for (int qualifierIndex = 0; qualifierIndex < qualifierEnum.keyCount(); qualifierIndex++) {
+            const auto qualifierName = qualifierEnum.key(qualifierIndex);
+            const auto qualifierValue = static_cast<QShaderLanguage::StorageQualifier>(qualifierEnum.value(qualifierIndex));
+
+            for (int typeIndex = 0; typeIndex < typeEnum.keyCount(); typeIndex++) {
+                const auto typeName = typeEnum.key(typeIndex);
+                const auto typeValue = static_cast<QShaderLanguage::VariableType>(typeEnum.value(typeIndex));
+
+                auto graph = QShaderGraph();
+
+                auto worldPosition = createNode({
+                    createPort(QShaderNodePort::Output, "value")
+                });
+                worldPosition.setParameter("name", "worldPosition");
+                worldPosition.setParameter("qualifier", QVariant::fromValue<QShaderLanguage::StorageQualifier>(qualifierValue));
+                worldPosition.setParameter("type", QVariant::fromValue<QShaderLanguage::VariableType>(typeValue));
+                worldPosition.addRule(es2, QShaderNode::Rule("highp $type $value = $name;",
+                                                             QByteArrayList() << "$qualifier highp $type $name;"));
+                worldPosition.addRule(gl2, QShaderNode::Rule("$type $value = $name;",
+                                                             QByteArrayList() << "$qualifier $type $name;"));
+                worldPosition.addRule(gl3, QShaderNode::Rule("$type $value = $name;",
+                                                             QByteArrayList() << "$qualifier $type $name;"));
+
+                auto fragColor = createNode({
+                    createPort(QShaderNodePort::Input, "fragColor")
+                });
+                fragColor.addRule(es2, QShaderNode::Rule("gl_fragColor = $fragColor;"));
+                fragColor.addRule(gl2, QShaderNode::Rule("gl_fragColor = $fragColor;"));
+                fragColor.addRule(gl3, QShaderNode::Rule("fragColor = $fragColor;",
+                                                         QByteArrayList() << "out vec4 fragColor;"));
+
+                graph.addNode(worldPosition);
+                graph.addNode(fragColor);
+
+                graph.addEdge(createEdge(worldPosition.uuid(), "value", fragColor.uuid(), "fragColor"));
+
+                const auto gl2Code = (QByteArrayList() << "#version 110"
+                                                       << ""
+                                                       << QStringLiteral("%1 %2 worldPosition;").arg(toGlsl(qualifierValue, gl2))
+                                                                                                .arg(toGlsl(typeValue))
+                                                                                                .toUtf8()
+                                                       << ""
+                                                       << "void main()"
+                                                       << "{"
+                                                       << "    gl_fragColor = worldPosition;"
+                                                       << "}"
+                                                       << "").join("\n");
+                const auto gl3Code = (QByteArrayList() << "#version 130"
+                                                       << ""
+                                                       << QStringLiteral("%1 %2 worldPosition;").arg(toGlsl(qualifierValue, gl3))
+                                                                                                .arg(toGlsl(typeValue))
+                                                                                                .toUtf8()
+                                                       << "out vec4 fragColor;"
+                                                       << ""
+                                                       << "void main()"
+                                                       << "{"
+                                                       << "    fragColor = worldPosition;"
+                                                       << "}"
+                                                       << "").join("\n");
+                const auto gl4Code = (QByteArrayList() << "#version 400 core"
+                                                       << ""
+                                                       << QStringLiteral("%1 %2 worldPosition;").arg(toGlsl(qualifierValue, gl4))
+                                                                                                .arg(toGlsl(typeValue))
+                                                                                                .toUtf8()
+                                                       << "out vec4 fragColor;"
+                                                       << ""
+                                                       << "void main()"
+                                                       << "{"
+                                                       << "    fragColor = worldPosition;"
+                                                       << "}"
+                                                       << "").join("\n");
+                const auto es2Code = (QByteArrayList() << "#version 100"
+                                                       << ""
+                                                       << QStringLiteral("%1 highp %2 worldPosition;").arg(toGlsl(qualifierValue, es2))
+                                                                                                      .arg(toGlsl(typeValue))
+                                                                                                      .toUtf8()
+                                                       << ""
+                                                       << "void main()"
+                                                       << "{"
+                                                       << "    gl_fragColor = worldPosition;"
+                                                       << "}"
+                                                       << "").join("\n");
+                const auto es3Code = (QByteArrayList() << "#version 300 es"
+                                                       << ""
+                                                       << QStringLiteral("%1 highp %2 worldPosition;").arg(toGlsl(qualifierValue, es3))
+                                                                                                      .arg(toGlsl(typeValue))
+                                                                                                      .toUtf8()
+                                                       << ""
+                                                       << "void main()"
+                                                       << "{"
+                                                       << "    gl_fragColor = worldPosition;"
+                                                       << "}"
+                                                       << "").join("\n");
+
+                QTest::addRow("%s %s ES2", qualifierName, typeName) << graph << es2 << es2Code;
+                QTest::addRow("%s %s ES3", qualifierName, typeName) << graph << es3 << es3Code;
+                QTest::addRow("%s %s GL2", qualifierName, typeName) << graph << gl2 << gl2Code;
+                QTest::addRow("%s %s GL3", qualifierName, typeName) << graph << gl3 << gl3Code;
+                QTest::addRow("%s %s GL4", qualifierName, typeName) << graph << gl4 << gl4Code;
+            }
+        }
+    }
 
-        for (int typeIndex = 0; typeIndex < typeEnum.keyCount(); typeIndex++) {
-            const auto typeName = typeEnum.key(typeIndex);
-            const auto typeValue = static_cast<QShaderLanguage::VariableType>(typeEnum.value(typeIndex));
+    {
+            const auto es2 = createFormat(QShaderFormat::OpenGLES, 2, 0, QShaderFormat::Vertex);
+            const auto es3 = createFormat(QShaderFormat::OpenGLES, 3, 0, QShaderFormat::Vertex);
+            const auto gl2 = createFormat(QShaderFormat::OpenGLNoProfile, 2, 0, QShaderFormat::Vertex);
+            const auto gl3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0, QShaderFormat::Vertex);
+            const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0, QShaderFormat::Vertex);
 
             auto graph = QShaderGraph();
 
-            auto worldPosition = createNode({
+            auto vertexPosition = createNode({
                 createPort(QShaderNodePort::Output, "value")
             });
-            worldPosition.setParameter("name", "worldPosition");
-            worldPosition.setParameter("qualifier", QVariant::fromValue<QShaderLanguage::StorageQualifier>(qualifierValue));
-            worldPosition.setParameter("type", QVariant::fromValue<QShaderLanguage::VariableType>(typeValue));
-            worldPosition.addRule(es2, QShaderNode::Rule("highp $type $value = $name;",
+            vertexPosition.setParameter("name", "vertexPosition");
+            vertexPosition.setParameter("qualifier", QVariant::fromValue<QShaderLanguage::StorageQualifier>(QShaderLanguage::Input));
+            vertexPosition.setParameter("type", QVariant::fromValue<QShaderLanguage::VariableType>(QShaderLanguage::Vec4));
+
+            vertexPosition.addRule(es2, QShaderNode::Rule("",
                                                          QByteArrayList() << "$qualifier highp $type $name;"));
-            worldPosition.addRule(gl2, QShaderNode::Rule("$type $value = $name;",
+            vertexPosition.addRule(gl2, QShaderNode::Rule("",
                                                          QByteArrayList() << "$qualifier $type $name;"));
-            worldPosition.addRule(gl3, QShaderNode::Rule("$type $value = $name;",
+            vertexPosition.addRule(gl3, QShaderNode::Rule("",
                                                          QByteArrayList() << "$qualifier $type $name;"));
 
-            auto fragColor = createNode({
-                createPort(QShaderNodePort::Input, "fragColor")
-            });
-            fragColor.addRule(es2, QShaderNode::Rule("gl_fragColor = $fragColor;"));
-            fragColor.addRule(gl2, QShaderNode::Rule("gl_fragColor = $fragColor;"));
-            fragColor.addRule(gl3, QShaderNode::Rule("fragColor = $fragColor;",
-                                                     QByteArrayList() << "out vec4 fragColor;"));
-
-            graph.addNode(worldPosition);
-            graph.addNode(fragColor);
-
-            graph.addEdge(createEdge(worldPosition.uuid(), "value", fragColor.uuid(), "fragColor"));
+            graph.addNode(vertexPosition);
 
             const auto gl2Code = (QByteArrayList() << "#version 110"
                                                    << ""
-                                                   << QStringLiteral("%1 %2 worldPosition;").arg(toGlsl(qualifierValue, gl2))
-                                                                                            .arg(toGlsl(typeValue))
-                                                                                            .toUtf8()
+                                                   << "attribute vec4 vertexPosition;"
                                                    << ""
                                                    << "void main()"
                                                    << "{"
-                                                   << QStringLiteral("    %1 v0 = worldPosition;").arg(toGlsl(typeValue)).toUtf8()
-                                                   << "    gl_fragColor = v0;"
                                                    << "}"
                                                    << "").join("\n");
             const auto gl3Code = (QByteArrayList() << "#version 130"
                                                    << ""
-                                                   << QStringLiteral("%1 %2 worldPosition;").arg(toGlsl(qualifierValue, gl3))
-                                                                                            .arg(toGlsl(typeValue))
-                                                                                            .toUtf8()
-                                                   << "out vec4 fragColor;"
+                                                   << "in vec4 vertexPosition;"
                                                    << ""
                                                    << "void main()"
                                                    << "{"
-                                                   << QStringLiteral("    %1 v0 = worldPosition;").arg(toGlsl(typeValue)).toUtf8()
-                                                   << "    fragColor = v0;"
                                                    << "}"
                                                    << "").join("\n");
             const auto gl4Code = (QByteArrayList() << "#version 400 core"
                                                    << ""
-                                                   << QStringLiteral("%1 %2 worldPosition;").arg(toGlsl(qualifierValue, gl4))
-                                                                                            .arg(toGlsl(typeValue))
-                                                                                            .toUtf8()
-                                                   << "out vec4 fragColor;"
+                                                   << "in vec4 vertexPosition;"
                                                    << ""
                                                    << "void main()"
                                                    << "{"
-                                                   << QStringLiteral("    %1 v0 = worldPosition;").arg(toGlsl(typeValue)).toUtf8()
-                                                   << "    fragColor = v0;"
                                                    << "}"
                                                    << "").join("\n");
             const auto es2Code = (QByteArrayList() << "#version 100"
                                                    << ""
-                                                   << QStringLiteral("%1 highp %2 worldPosition;").arg(toGlsl(qualifierValue, es2))
-                                                                                                  .arg(toGlsl(typeValue))
-                                                                                                  .toUtf8()
+                                                   << "attribute highp vec4 vertexPosition;"
                                                    << ""
                                                    << "void main()"
                                                    << "{"
-                                                   << QStringLiteral("    highp %1 v0 = worldPosition;").arg(toGlsl(typeValue)).toUtf8()
-                                                   << "    gl_fragColor = v0;"
                                                    << "}"
                                                    << "").join("\n");
             const auto es3Code = (QByteArrayList() << "#version 300 es"
                                                    << ""
-                                                   << QStringLiteral("%1 highp %2 worldPosition;").arg(toGlsl(qualifierValue, es3))
-                                                                                                  .arg(toGlsl(typeValue))
-                                                                                                  .toUtf8()
+                                                   << "in highp vec4 vertexPosition;"
                                                    << ""
                                                    << "void main()"
                                                    << "{"
-                                                   << QStringLiteral("    highp %1 v0 = worldPosition;").arg(toGlsl(typeValue)).toUtf8()
-                                                   << "    gl_fragColor = v0;"
                                                    << "}"
                                                    << "").join("\n");
 
-            QTest::addRow("%s %s ES2", qualifierName, typeName) << graph << es2 << es2Code;
-            QTest::addRow("%s %s ES3", qualifierName, typeName) << graph << es3 << es3Code;
-            QTest::addRow("%s %s GL2", qualifierName, typeName) << graph << gl2 << gl2Code;
-            QTest::addRow("%s %s GL3", qualifierName, typeName) << graph << gl3 << gl3Code;
-            QTest::addRow("%s %s GL4", qualifierName, typeName) << graph << gl4 << gl4Code;
-        }
+            QTest::addRow("Attribute header substitution ES2") << graph << es2 << es2Code;
+            QTest::addRow("Attribute header substitution ES3") << graph << es3 << es3Code;
+            QTest::addRow("Attribute header substitution GL2") << graph << gl2 << gl2Code;
+            QTest::addRow("Attribute header substitution GL3") << graph << gl3 << gl3Code;
+            QTest::addRow("Attribute header substitution GL4") << graph << gl4 << gl4Code;
     }
 }
 
@@ -806,9 +869,7 @@ void tst_QShaderGenerator::shouldGenerateDifferentCodeDependingOnActiveLayers()
                 << ""
                 << "void main()"
                 << "{"
-                << "    vec3 v1 = normalUniform;"
-                << "    vec4 v0 = diffuseUniform;"
-                << "    vec4 v2 = lightModel(v0, v1);"
+                << "    vec4 v2 = lightModel(diffuseUniform, normalUniform);"
                 << "    fragColor = v2;"
                 << "}"
                 << "";
@@ -831,10 +892,8 @@ void tst_QShaderGenerator::shouldGenerateDifferentCodeDependingOnActiveLayers()
                 << ""
                 << "void main()"
                 << "{"
-                << "    vec2 v0 = texCoord;"
-                << "    vec3 v2 = texture2D(normalTexture, v0).rgb;"
-                << "    vec4 v1 = diffuseUniform;"
-                << "    vec4 v3 = lightModel(v1, v2);"
+                << "    vec3 v2 = texture2D(normalTexture, texCoord).rgb;"
+                << "    vec4 v3 = lightModel(diffuseUniform, v2);"
                 << "    fragColor = v3;"
                 << "}"
                 << "";
@@ -857,10 +916,8 @@ void tst_QShaderGenerator::shouldGenerateDifferentCodeDependingOnActiveLayers()
                 << ""
                 << "void main()"
                 << "{"
-                << "    vec2 v0 = texCoord;"
-                << "    vec3 v2 = normalUniform;"
-                << "    vec4 v1 = texture2D(diffuseTexture, v0);"
-                << "    vec4 v3 = lightModel(v1, v2);"
+                << "    vec4 v1 = texture2D(diffuseTexture, texCoord);"
+                << "    vec4 v3 = lightModel(v1, normalUniform);"
                 << "    fragColor = v3;"
                 << "}"
                 << "";
@@ -883,9 +940,8 @@ void tst_QShaderGenerator::shouldGenerateDifferentCodeDependingOnActiveLayers()
                 << ""
                 << "void main()"
                 << "{"
-                << "    vec2 v0 = texCoord;"
-                << "    vec3 v2 = texture2D(normalTexture, v0).rgb;"
-                << "    vec4 v1 = texture2D(diffuseTexture, v0);"
+                << "    vec3 v2 = texture2D(normalTexture, texCoord).rgb;"
+                << "    vec4 v1 = texture2D(diffuseTexture, texCoord);"
                 << "    vec4 v3 = lightModel(v1, v2);"
                 << "    fragColor = v3;"
                 << "}"
@@ -894,6 +950,133 @@ void tst_QShaderGenerator::shouldGenerateDifferentCodeDependingOnActiveLayers()
     }
 }
 
+void tst_QShaderGenerator::shouldUseGlobalVariableRatherThanTemporaries()
+{
+    // GIVEN
+    const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0);
+
+    {
+        // WHEN
+        auto vertexPosition = createNode({
+                                             createPort(QShaderNodePort::Output, "vertexPosition")
+                                         });
+        vertexPosition.addRule(gl4, QShaderNode::Rule("vec4 $vertexPosition = vertexPosition;",
+                                                      QByteArrayList() << "in vec4 vertexPosition;"));
+
+        auto fakeMultiPlyNoSpace = createNode({
+                                                  createPort(QShaderNodePort::Input, "varName"),
+                                                  createPort(QShaderNodePort::Output, "out")
+                                              });
+        fakeMultiPlyNoSpace.addRule(gl4, QShaderNode::Rule("vec4 $out = $varName*v11;"));
+
+        auto fakeMultiPlySpace = createNode({
+                                                  createPort(QShaderNodePort::Input, "varName"),
+                                                  createPort(QShaderNodePort::Output, "out")
+                                              });
+        fakeMultiPlySpace.addRule(gl4, QShaderNode::Rule("vec4 $out = $varName * v11;"));
+
+        auto fakeJoinNoSpace = createNode({
+                                                  createPort(QShaderNodePort::Input, "varName"),
+                                                  createPort(QShaderNodePort::Output, "out")
+                                          });
+        fakeJoinNoSpace.addRule(gl4, QShaderNode::Rule("vec4 $out = vec4($varName.xyz,$varName.w);"));
+
+        auto fakeJoinSpace = createNode({
+                                              createPort(QShaderNodePort::Input, "varName"),
+                                              createPort(QShaderNodePort::Output, "out")
+                                          });
+        fakeJoinSpace.addRule(gl4, QShaderNode::Rule("vec4 $out = vec4($varName.xyz, $varName.w);"));
+
+        auto fakeAdd = createNode({
+                                            createPort(QShaderNodePort::Input, "varName"),
+                                            createPort(QShaderNodePort::Output, "out")
+                                        });
+        fakeAdd.addRule(gl4, QShaderNode::Rule("vec4 $out = $varName.xyzw + $varName;"));
+
+        auto fakeSub = createNode({
+                                            createPort(QShaderNodePort::Input, "varName"),
+                                            createPort(QShaderNodePort::Output, "out")
+                                        });
+        fakeSub.addRule(gl4, QShaderNode::Rule("vec4 $out = $varName.xyzw - $varName;"));
+
+        auto fakeDiv = createNode({
+                                            createPort(QShaderNodePort::Input, "varName"),
+                                            createPort(QShaderNodePort::Output, "out")
+                                        });
+        fakeDiv.addRule(gl4, QShaderNode::Rule("vec4 $out = $varName / v0;"));
+
+        auto fragColor = createNode({
+            createPort(QShaderNodePort::Input, "input1"),
+            createPort(QShaderNodePort::Input, "input2"),
+            createPort(QShaderNodePort::Input, "input3"),
+            createPort(QShaderNodePort::Input, "input4"),
+            createPort(QShaderNodePort::Input, "input5"),
+            createPort(QShaderNodePort::Input, "input6"),
+            createPort(QShaderNodePort::Input, "input7")
+        });
+        fragColor.addRule(gl4, QShaderNode::Rule("fragColor = $input1 + $input2 + $input3 + $input4 + $input5 + $input6 + $input7;",
+                                                 QByteArrayList() << "out vec4 fragColor;"));
+
+        const auto graph = [=] {
+            auto res = QShaderGraph();
+
+            res.addNode(vertexPosition);
+            res.addNode(fakeMultiPlyNoSpace);
+            res.addNode(fakeMultiPlySpace);
+            res.addNode(fakeJoinNoSpace);
+            res.addNode(fakeJoinSpace);
+            res.addNode(fakeAdd);
+            res.addNode(fakeSub);
+            res.addNode(fakeDiv);
+            res.addNode(fragColor);
+
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeMultiPlyNoSpace.uuid(), "varName"));
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeMultiPlySpace.uuid(), "varName"));
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeJoinNoSpace.uuid(), "varName"));
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeJoinSpace.uuid(), "varName"));
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeAdd.uuid(), "varName"));
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeSub.uuid(), "varName"));
+            res.addEdge(createEdge(vertexPosition.uuid(), "vertexPosition", fakeDiv.uuid(), "varName"));
+            res.addEdge(createEdge(fakeMultiPlyNoSpace.uuid(), "out", fragColor.uuid(), "input1"));
+            res.addEdge(createEdge(fakeMultiPlySpace.uuid(), "out", fragColor.uuid(), "input2"));
+            res.addEdge(createEdge(fakeJoinNoSpace.uuid(), "out", fragColor.uuid(), "input3"));
+            res.addEdge(createEdge(fakeJoinSpace.uuid(), "out", fragColor.uuid(), "input4"));
+            res.addEdge(createEdge(fakeAdd.uuid(), "out", fragColor.uuid(), "input5"));
+            res.addEdge(createEdge(fakeSub.uuid(), "out", fragColor.uuid(), "input6"));
+            res.addEdge(createEdge(fakeDiv.uuid(), "out", fragColor.uuid(), "input7"));
+
+            return res;
+        }();
+
+        auto generator = QShaderGenerator();
+        generator.graph = graph;
+        generator.format = gl4;
+
+        const auto code = generator.createShaderCode({"diffuseUniform", "normalUniform"});
+
+        // THEN
+        const auto expected = QByteArrayList()
+                << "#version 400 core"
+                << ""
+                << "in vec4 vertexPosition;"
+                << "out vec4 fragColor;"
+                << ""
+                << "void main()"
+                << "{"
+                << "    vec4 v7 = vertexPosition / vertexPosition;"
+                << "    vec4 v6 = vertexPosition.xyzw - vertexPosition;"
+                << "    vec4 v5 = vertexPosition.xyzw + vertexPosition;"
+                << "    vec4 v4 = vec4(vertexPosition.xyz, vertexPosition.w);"
+                << "    vec4 v3 = vec4(vertexPosition.xyz,vertexPosition.w);"
+                << "    vec4 v2 = vertexPosition * v11;"
+                << "    vec4 v1 = vertexPosition*v11;"
+                << "    fragColor = v1 + v2 + v3 + v4 + v5 + v6 + v7;"
+                << "}"
+                << "";
+        QCOMPARE(code, expected.join("\n"));
+    }
+}
+
 QTEST_MAIN(tst_QShaderGenerator)
 
 #include "tst_qshadergenerator.moc"
diff --git a/tests/auto/widgets/styles/qstylesheetstyle/tst_qstylesheetstyle.cpp b/tests/auto/widgets/styles/qstylesheetstyle/tst_qstylesheetstyle.cpp
index 61b1fed1f8..a671a6c4d8 100644
--- a/tests/auto/widgets/styles/qstylesheetstyle/tst_qstylesheetstyle.cpp
+++ b/tests/auto/widgets/styles/qstylesheetstyle/tst_qstylesheetstyle.cpp
@@ -48,6 +48,7 @@ public:
 private slots:
     void init();
     void repolish();
+    void repolish_without_crashing();
     void numinstances();
     void widgetsBeforeAppStyleSheet();
     void widgetsAfterAppStyleSheet();
@@ -367,6 +368,26 @@ void tst_QStyleSheetStyle::repolish()
     QCOMPARE(BACKGROUND(p1), APPBACKGROUND(p1));
 }
 
+void tst_QStyleSheetStyle::repolish_without_crashing()
+{
+    // This used to crash, QTBUG-69204
+    QMainWindow w;
+    QScopedPointer<QSplitter> splitter1(new QSplitter(w.centralWidget()));
+    QScopedPointer<QSplitter> splitter2(new QSplitter);
+    QScopedPointer<QSplitter> splitter3(new QSplitter);
+    splitter2->addWidget(splitter3.data());
+
+    splitter2->setStyleSheet("color: red");
+    QScopedPointer<QLabel> label(new QLabel);
+    label->setTextFormat(Qt::RichText);
+    splitter3->addWidget(label.data());
+    label->setText("hey");
+
+    splitter1->addWidget(splitter2.data());
+    w.show();
+    QCOMPARE(COLOR(*label), QColor(Qt::red));
+}
+
 void tst_QStyleSheetStyle::widgetStyle()
 {
     qApp->setStyleSheet(QString());