Imports, Plugins, Quick: replace QStringLiteral with QL1S

.. in such cases:
- if there is overloaded function
- in QStringBuilder expressions

Result: reducing .rodata

Change-Id: I972bc0a61df7b5567c40329dd47e77176d9a5b96
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

5 files changed, 76 insertions, 76 deletions

diff --git a/src/imports/statemachine/signaltransition.cpp b/src/imports/statemachine/signaltransition.cpp
index 4153c70fd0..127494d8d3 100644
--- a/src/imports/statemachine/signaltransition.cpp
+++ b/src/imports/statemachine/signaltransition.cpp
@@ -178,7 +178,7 @@ void SignalTransitionParser::verifyBindings(const QV4::CompiledData::Unit *qmlUn
 
         QString propName = qmlUnit->stringAt(binding->propertyNameIndex);
 
-        if (propName != QStringLiteral("onTriggered")) {
+        if (propName != QLatin1String("onTriggered")) {
             error(props.at(ii), SignalTransition::tr("Cannot assign to non-existent property \"%1\"").arg(propName));
             return;
         }
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qqmlnativedebugservice.cpp b/src/plugins/qmltooling/qmldbg_debugger/qqmlnativedebugservice.cpp
index 99f5b760ba..9f44c4ec81 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qqmlnativedebugservice.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qqmlnativedebugservice.cpp
@@ -143,15 +143,15 @@ public:
 void BreakPointHandler::handleSetBreakpoint(QJsonObject *response, const QJsonObject &arguments)
 {
     TRACE_PROTOCOL("SET BREAKPOINT" << arguments);
-    QString type = arguments.value(QStringLiteral("type")).toString();
+    QString type = arguments.value(QLatin1String("type")).toString();
 
-    QString fileName = arguments.value(QStringLiteral("file")).toString();
+    QString fileName = arguments.value(QLatin1String("file")).toString();
     if (fileName.isEmpty()) {
         setError(response, QStringLiteral("breakpoint has no file name"));
         return;
     }
 
-    int line = arguments.value(QStringLiteral("line")).toInt(-1);
+    int line = arguments.value(QLatin1String("line")).toInt(-1);
     if (line < 0) {
         setError(response, QStringLiteral("breakpoint has an invalid line number"));
         return;
@@ -161,9 +161,9 @@ void BreakPointHandler::handleSetBreakpoint(QJsonObject *response, const QJsonOb
     bp.id = m_lastBreakpoint++;
     bp.fileName = fileName.mid(fileName.lastIndexOf('/') + 1);
     bp.lineNumber = line;
-    bp.enabled  = arguments.value(QStringLiteral("enabled")).toBool(true);
-    bp.condition = arguments.value(QStringLiteral("condition")).toString();
-    bp.ignoreCount = arguments.value(QStringLiteral("ignorecount")).toInt();
+    bp.enabled  = arguments.value(QLatin1String("enabled")).toBool(true);
+    bp.condition = arguments.value(QLatin1String("condition")).toString();
+    bp.ignoreCount = arguments.value(QLatin1String("ignorecount")).toInt();
     m_breakPoints.append(bp);
 
     m_haveBreakPoints = true;
@@ -174,7 +174,7 @@ void BreakPointHandler::handleSetBreakpoint(QJsonObject *response, const QJsonOb
 
 void BreakPointHandler::handleRemoveBreakpoint(QJsonObject *response, const QJsonObject &arguments)
 {
-    int id = arguments.value(QStringLiteral("id")).toInt();
+    int id = arguments.value(QLatin1String("id")).toInt();
     removeBreakPoint(id);
     response->insert(QStringLiteral("id"), id);
 }
@@ -301,19 +301,19 @@ void NativeDebugger::signalEmitted(const QString &signal)
 void NativeDebugger::handleCommand(QJsonObject *response, const QString &cmd,
                                    const QJsonObject &arguments)
 {
-    if (cmd == QStringLiteral("backtrace"))
+    if (cmd == QLatin1String("backtrace"))
         handleBacktrace(response, arguments);
-    else if (cmd == QStringLiteral("variables"))
+    else if (cmd == QLatin1String("variables"))
         handleVariables(response, arguments);
-    else if (cmd == QStringLiteral("expressions"))
+    else if (cmd == QLatin1String("expressions"))
         handleExpressions(response, arguments);
-    else if (cmd == QStringLiteral("stepin"))
+    else if (cmd == QLatin1String("stepin"))
         handleContinue(response, StepIn);
-    else if (cmd == QStringLiteral("stepout"))
+    else if (cmd == QLatin1String("stepout"))
         handleContinue(response, StepOut);
-    else if (cmd == QStringLiteral("stepover"))
+    else if (cmd == QLatin1String("stepover"))
         handleContinue(response, StepOver);
-    else if (cmd == QStringLiteral("continue"))
+    else if (cmd == QLatin1String("continue"))
         handleContinue(response, NotStepping);
 }
 
@@ -334,7 +334,7 @@ static void decodeContext(const QString &context, QV4::ExecutionContext **execut
 
 void NativeDebugger::handleBacktrace(QJsonObject *response, const QJsonObject &arguments)
 {
-    int limit = arguments.value(QStringLiteral("limit")).toInt(0);
+    int limit = arguments.value(QLatin1String("limit")).toInt(0);
 
     QJsonArray frameArray;
     QV4::ExecutionContext *executionContext = m_engine->currentContext;
@@ -463,7 +463,7 @@ void NativeDebugger::handleVariables(QJsonObject *response, const QJsonObject &a
 {
     TRACE_PROTOCOL("Build variables");
     QV4::ExecutionContext *executionContext = 0;
-    decodeContext(arguments.value(QStringLiteral("context")).toString(), &executionContext);
+    decodeContext(arguments.value(QLatin1String("context")).toString(), &executionContext);
     if (!executionContext) {
         setError(response, QStringLiteral("No execution context passed"));
         return;
@@ -478,7 +478,7 @@ void NativeDebugger::handleVariables(QJsonObject *response, const QJsonObject &a
     TRACE_PROTOCOL("Engine: " << engine);
 
     Collector collector(engine);
-    QJsonArray expanded = arguments.value(QStringLiteral("expanded")).toArray();
+    QJsonArray expanded = arguments.value(QLatin1String("expanded")).toArray();
     foreach (const QJsonValue &ex, expanded)
         collector.m_expanded.append(ex.toString());
     TRACE_PROTOCOL("Expanded: " << collector.m_expanded);
@@ -515,7 +515,7 @@ void NativeDebugger::handleExpressions(QJsonObject *response, const QJsonObject
 {
     TRACE_PROTOCOL("Evaluate expressions");
     QV4::ExecutionContext *executionContext = 0;
-    decodeContext(arguments.value(QStringLiteral("context")).toString(), &executionContext);
+    decodeContext(arguments.value(QLatin1String("context")).toString(), &executionContext);
     if (!executionContext) {
         setError(response, QStringLiteral("No execution context passed"));
         return;
@@ -530,7 +530,7 @@ void NativeDebugger::handleExpressions(QJsonObject *response, const QJsonObject
     TRACE_PROTOCOL("Engines: " << engine << m_engine);
 
     Collector collector(engine);
-    QJsonArray expanded = arguments.value(QStringLiteral("expanded")).toArray();
+    QJsonArray expanded = arguments.value(QLatin1String("expanded")).toArray();
     foreach (const QJsonValue &ex, expanded)
         collector.m_expanded.append(ex.toString());
     TRACE_PROTOCOL("Expanded: " << collector.m_expanded);
@@ -538,10 +538,10 @@ void NativeDebugger::handleExpressions(QJsonObject *response, const QJsonObject
     QJsonArray output;
     QV4::Scope scope(engine);
 
-    QJsonArray expressions = arguments.value(QStringLiteral("expressions")).toArray();
+    QJsonArray expressions = arguments.value(QLatin1String("expressions")).toArray();
     foreach (const QJsonValue &expr, expressions) {
-        QString expression = expr.toObject().value(QStringLiteral("expression")).toString();
-        QString name = expr.toObject().value(QStringLiteral("name")).toString();
+        QString expression = expr.toObject().value(QLatin1String("expression")).toString();
+        QString name = expr.toObject().value(QLatin1String("name")).toString();
         TRACE_PROTOCOL("Evaluate expression: " << expression);
         m_runningJob = true;
 
@@ -776,14 +776,14 @@ void QQmlNativeDebugServiceImpl::messageReceived(const QByteArray &message)
     TRACE_PROTOCOL("Native message received: " << message);
     QJsonObject request = QJsonDocument::fromJson(message).object();
     QJsonObject response;
-    QJsonObject arguments = request.value(QStringLiteral("arguments")).toObject();
-    QString cmd = request.value(QStringLiteral("command")).toString();
+    QJsonObject arguments = request.value(QLatin1String("arguments")).toObject();
+    QString cmd = request.value(QLatin1String("command")).toString();
 
-    if (cmd == QStringLiteral("setbreakpoint")) {
+    if (cmd == QLatin1String("setbreakpoint")) {
         m_breakHandler->handleSetBreakpoint(&response, arguments);
-    } else if (cmd == QStringLiteral("removebreakpoint")) {
+    } else if (cmd == QLatin1String("removebreakpoint")) {
         m_breakHandler->handleRemoveBreakpoint(&response, arguments);
-    } else if (cmd == QStringLiteral("echo")) {
+    } else if (cmd == QLatin1String("echo")) {
         response.insert(QStringLiteral("result"), arguments);
     } else {
         foreach (NativeDebugger *debugger, m_debuggers)
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp b/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp
index 5ee9e5e9e9..c87ca47c49 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp
@@ -90,7 +90,7 @@ public:
         TRACE_PROTOCOL(qDebug() << "handling command" << command() << "...");
 
         req = request;
-        seq = req.value(QStringLiteral("seq"));
+        seq = req.value(QLatin1String("seq"));
         debugService = s;
 
         handleRequest();
@@ -128,7 +128,7 @@ protected:
 
     void createErrorResponse(const QString &msg)
     {
-        QJsonValue command = req.value(QStringLiteral("command"));
+        QJsonValue command = req.value(QLatin1String("command"));
         response.insert(QStringLiteral("command"), command);
         addRequestSequence();
         addSuccess(false);
@@ -154,9 +154,9 @@ public:
 
     virtual void handleRequest()
     {
-        QString msg = QStringLiteral("unimplemented command \"");
-        msg += req.value(QStringLiteral("command")).toString();
-        msg += QLatin1Char('"');
+        QString msg = QLatin1String("unimplemented command \"")
+                + req.value(QLatin1String("command")).toString()
+                + QLatin1Char('"');
         createErrorResponse(msg);
     }
 };
@@ -189,23 +189,23 @@ public:
     virtual void handleRequest()
     {
         // decypher the payload:
-        QJsonObject args = req.value(QStringLiteral("arguments")).toObject();
+        QJsonObject args = req.value(QLatin1String("arguments")).toObject();
         if (args.isEmpty())
             return;
 
-        QString type = args.value(QStringLiteral("type")).toString();
-        if (type != QStringLiteral("scriptRegExp")) {
+        QString type = args.value(QLatin1String("type")).toString();
+        if (type != QLatin1String("scriptRegExp")) {
             createErrorResponse(QStringLiteral("breakpoint type \"%1\" is not implemented").arg(type));
             return;
         }
 
-        QString fileName = args.value(QStringLiteral("target")).toString();
+        QString fileName = args.value(QLatin1String("target")).toString();
         if (fileName.isEmpty()) {
             createErrorResponse(QStringLiteral("breakpoint has no file name"));
             return;
         }
 
-        int line = args.value(QStringLiteral("line")).toInt(-1);
+        int line = args.value(QLatin1String("line")).toInt(-1);
         if (line < 0) {
             createErrorResponse(QStringLiteral("breakpoint has an invalid line number"));
             return;
@@ -240,11 +240,11 @@ public:
     virtual void handleRequest()
     {
         // decypher the payload:
-        QJsonObject args = req.value(QStringLiteral("arguments")).toObject();
+        QJsonObject args = req.value(QLatin1String("arguments")).toObject();
         if (args.isEmpty())
             return;
 
-        int id = args.value(QStringLiteral("breakpoint")).toInt(-1);
+        int id = args.value(QLatin1String("breakpoint")).toInt(-1);
         if (id < 0) {
             createErrorResponse(QStringLiteral("breakpoint has an invalid number"));
             return;
@@ -274,9 +274,9 @@ public:
     {
         // decypher the payload:
 
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        int fromFrame = arguments.value(QStringLiteral("fromFrame")).toInt(0);
-        int toFrame = arguments.value(QStringLiteral("toFrame")).toInt(fromFrame + 10);
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        int fromFrame = arguments.value(QLatin1String("fromFrame")).toInt(0);
+        int toFrame = arguments.value(QLatin1String("toFrame")).toInt(fromFrame + 10);
         // no idea what the bottom property is for, so we'll ignore it.
 
         QV4Debugger *debugger = debugService->debuggerAgent.pausedDebugger();
@@ -306,8 +306,8 @@ public:
     virtual void handleRequest()
     {
         // decypher the payload:
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        const int frameNr = arguments.value(QStringLiteral("number")).toInt(
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        const int frameNr = arguments.value(QLatin1String("number")).toInt(
                     debugService->selectedFrame());
 
         QV4Debugger *debugger = debugService->debuggerAgent.pausedDebugger();
@@ -348,10 +348,10 @@ public:
     virtual void handleRequest()
     {
         // decypher the payload:
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        const int frameNr = arguments.value(QStringLiteral("frameNumber")).toInt(
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        const int frameNr = arguments.value(QLatin1String("frameNumber")).toInt(
                     debugService->selectedFrame());
-        const int scopeNr = arguments.value(QStringLiteral("number")).toInt(0);
+        const int scopeNr = arguments.value(QLatin1String("number")).toInt(0);
 
         QV4Debugger *debugger = debugService->debuggerAgent.pausedDebugger();
         if (!debugger) {
@@ -393,8 +393,8 @@ public:
     virtual void handleRequest()
     {
         // decypher the payload:
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        QJsonArray handles = arguments.value(QStringLiteral("handles")).toArray();
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        QJsonArray handles = arguments.value(QLatin1String("handles")).toArray();
 
         QV4Debugger *debugger = debugService->debuggerAgent.pausedDebugger();
         if (!debugger) {
@@ -433,7 +433,7 @@ public:
     virtual void handleRequest()
     {
         // decypher the payload:
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
 
         QV4Debugger *debugger = debugService->debuggerAgent.pausedDebugger();
         if (!debugger) {
@@ -445,17 +445,17 @@ public:
         if (arguments.empty()) {
             debugger->resume(QV4Debugger::FullThrottle);
         } else {
-            QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-            QString stepAction = arguments.value(QStringLiteral("stepaction")).toString();
-            const int stepcount = arguments.value(QStringLiteral("stepcount")).toInt(1);
+            QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+            QString stepAction = arguments.value(QLatin1String("stepaction")).toString();
+            const int stepcount = arguments.value(QLatin1String("stepcount")).toInt(1);
             if (stepcount != 1)
                 qWarning() << "Step count other than 1 is not supported.";
 
-            if (stepAction == QStringLiteral("in")) {
+            if (stepAction == QLatin1String("in")) {
                 debugger->resume(QV4Debugger::StepIn);
-            } else if (stepAction == QStringLiteral("out")) {
+            } else if (stepAction == QLatin1String("out")) {
                 debugger->resume(QV4Debugger::StepOut);
-            } else if (stepAction == QStringLiteral("next")) {
+            } else if (stepAction == QLatin1String("next")) {
                 debugger->resume(QV4Debugger::StepOver);
             } else {
                 createErrorResponse(QStringLiteral("continue command has invalid stepaction"));
@@ -499,13 +499,13 @@ public:
         bool wasEnabled = debugService->debuggerAgent.breakOnThrow();
 
         //decypher the payload:
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        QString type = arguments.value(QStringLiteral("type")).toString();
-        bool enabled = arguments.value(QStringLiteral("number")).toBool(!wasEnabled);
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        QString type = arguments.value(QLatin1String("type")).toString();
+        bool enabled = arguments.value(QLatin1String("number")).toBool(!wasEnabled);
 
-        if (type == QStringLiteral("all")) {
+        if (type == QLatin1String("all")) {
             // that's fine
-        } else if (type == QStringLiteral("uncaught")) {
+        } else if (type == QLatin1String("uncaught")) {
             createErrorResponse(QStringLiteral("breaking only on uncaught exceptions is not supported yet"));
             return;
         } else {
@@ -537,8 +537,8 @@ public:
     virtual void handleRequest()
     {
         //decypher the payload:
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        int types = arguments.value(QStringLiteral("types")).toInt(-1);
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        int types = arguments.value(QLatin1String("types")).toInt(-1);
         if (types < 0 || types > 7) {
             createErrorResponse(QStringLiteral("invalid types value in scripts command"));
             return;
@@ -608,8 +608,8 @@ public:
 
     virtual void handleRequest()
     {
-        QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
-        QString expression = arguments.value(QStringLiteral("expression")).toString();
+        QJsonObject arguments = req.value(QLatin1String("arguments")).toObject();
+        QString expression = arguments.value(QLatin1String("expression")).toString();
         int frame = -1;
 
         QV4Debugger *debugger = debugService->debuggerAgent.pausedDebugger();
@@ -624,7 +624,7 @@ public:
             }
             debugger = debuggers.first();
         } else {
-            frame = arguments.value(QStringLiteral("frame")).toInt(0);
+            frame = arguments.value(QLatin1String("frame")).toInt(0);
         }
 
         ExpressionEvalJob job(debugger->engine(), frame, expression, debugger->collector());
@@ -802,9 +802,9 @@ void QV4DebugServiceImpl::handleV8Request(const QByteArray &payload)
 
     QJsonDocument request = QJsonDocument::fromJson(payload);
     QJsonObject o = request.object();
-    QJsonValue type = o.value(QStringLiteral("type"));
-    if (type.toString() == QStringLiteral("request")) {
-        QJsonValue command = o.value(QStringLiteral("command"));
+    QJsonValue type = o.value(QLatin1String("type"));
+    if (type.toString() == QLatin1String("request")) {
+        QJsonValue command = o.value(QLatin1String("command"));
         V8CommandHandler *h = v8CommandHandler(command.toString());
         if (h)
             h->handle(o, this);
diff --git a/src/qmltest/quicktestresult.cpp b/src/qmltest/quicktestresult.cpp
index 0a820b79db..e05d29bc05 100644
--- a/src/qmltest/quicktestresult.cpp
+++ b/src/qmltest/quicktestresult.cpp
@@ -248,7 +248,7 @@ void QuickTestResult::setDataTag(const QString &tag)
     if (!tag.isEmpty()) {
         QTestData *data = &(QTest::newRow(tag.toUtf8().constData()));
         QTestResult::setCurrentTestData(data);
-        QTestPrivate::checkBlackLists((testCaseName() + QStringLiteral("::") + functionName()).toUtf8().constData(), tag.toUtf8().constData());
+        QTestPrivate::checkBlackLists((testCaseName() + QLatin1String("::") + functionName()).toUtf8().constData(), tag.toUtf8().constData());
         emit dataTagChanged();
     } else {
         QTestResult::setCurrentTestData(0);
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index b2117d3eb9..10b02b1f32 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -2669,15 +2669,15 @@ QV4::ReturnedValue QQuickJSContext2D::method_set_textAlign(QV4::CallContext *ctx
     QString textAlign = s->toQString();
 
     QQuickContext2D::TextAlignType ta;
-    if (textAlign == QStringLiteral("start"))
+    if (textAlign == QLatin1String("start"))
         ta = QQuickContext2D::Start;
-    else if (textAlign == QStringLiteral("end"))
+    else if (textAlign == QLatin1String("end"))
         ta = QQuickContext2D::End;
-    else if (textAlign == QStringLiteral("left"))
+    else if (textAlign == QLatin1String("left"))
         ta = QQuickContext2D::Left;
-    else if (textAlign == QStringLiteral("right"))
+    else if (textAlign == QLatin1String("right"))
         ta = QQuickContext2D::Right;
-    else if (textAlign == QStringLiteral("center"))
+    else if (textAlign == QLatin1String("center"))
         ta = QQuickContext2D::Center;
     else
         return QV4::Encode::undefined();