Support QRegularExpression on the same level as QRegExp

QRegularExpression is the recommended way to do regular expressions
nowadays. Support assignment of JavaScript regular expressions to
QRegularExpression properties of QObjects and the other way around.
QJSValue::toVariant() will create a QRegularExpression from a JavaScript
RegExp by default now.

[ChangeLog][QtQml][Important Behavior Changes] QRegularExpression is now
supported the same way QRegExp is in QML. QJSValue::toVariant() creates
a QRegularExpression variant rather than a QRegExp one from a JavaScript
regular expression now.

Fixes: QTBUG-73429
Change-Id: I301a02771cd17903406c2bc5c7aaeca6cce629f0
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

8 files changed, 197 insertions, 20 deletions

diff --git a/tests/auto/qml/qjsengine/tst_qjsengine.cpp b/tests/auto/qml/qjsengine/tst_qjsengine.cpp
index fb9c7b0152..d2e0035b57 100644
--- a/tests/auto/qml/qjsengine/tst_qjsengine.cpp
+++ b/tests/auto/qml/qjsengine/tst_qjsengine.cpp
@@ -94,6 +94,7 @@ private slots:
     void valueConversion_basic2();
     void valueConversion_dateTime();
     void valueConversion_regExp();
+    void valueConversion_RegularExpression();
     void castWithMultipleInheritance();
     void collectGarbage();
     void gcWithNestedDataStructure();
@@ -135,6 +136,8 @@ private slots:
 
     void qRegExpInport_data();
     void qRegExpInport();
+    void qRegularExpressionImport_data();
+    void qRegularExpressionImport();
     void dateRoundtripJSQtJS();
     void dateRoundtripQtJSQt();
     void dateConversionJSQt();
@@ -520,22 +523,27 @@ void tst_QJSEngine::newVariant_valueOfEnum()
 void tst_QJSEngine::newRegExp()
 {
     QJSEngine eng;
-    QJSValue rexp = eng.toScriptValue(QRegExp("foo"));
-    QVERIFY(!rexp.isUndefined());
-    QCOMPARE(rexp.isRegExp(), true);
-    QCOMPARE(rexp.isObject(), true);
-    QCOMPARE(rexp.isCallable(), false);
-    // prototype should be RegExp.prototype
-    QVERIFY(!rexp.prototype().isUndefined());
-    QCOMPARE(rexp.prototype().isObject(), true);
-    // Get [[Class]] internal property of RegExp Prototype Object.
-    // See ECMA-262 Section 8.6.2, "Object Internal Properties and Methods".
-    // See ECMA-262 Section 15.10.6, "Properties of the RegExp Prototype Object".
-    QJSValue r = eng.evaluate("Object.prototype.toString.call(RegExp.prototype)");
-    QCOMPARE(r.toString(), QString::fromLatin1("[object Object]"));
-    QCOMPARE(rexp.prototype().strictlyEquals(eng.evaluate("RegExp.prototype")), true);
+    QJSValue rexps[] = {
+        eng.toScriptValue(QRegularExpression("foo")),
+        eng.toScriptValue(QRegExp("foo"))
+    };
+    for (const auto &rexp : rexps) {
+        QVERIFY(!rexp.isUndefined());
+        QCOMPARE(rexp.isRegExp(), true);
+        QCOMPARE(rexp.isObject(), true);
+        QCOMPARE(rexp.isCallable(), false);
+        // prototype should be RegExp.prototype
+        QVERIFY(!rexp.prototype().isUndefined());
+        QCOMPARE(rexp.prototype().isObject(), true);
+        // Get [[Class]] internal property of RegExp Prototype Object.
+        // See ECMA-262 Section 8.6.2, "Object Internal Properties and Methods".
+        // See ECMA-262 Section 15.10.6, "Properties of the RegExp Prototype Object".
+        QJSValue r = eng.evaluate("Object.prototype.toString.call(RegExp.prototype)");
+        QCOMPARE(r.toString(), QString::fromLatin1("[object Object]"));
+        QCOMPARE(rexp.prototype().strictlyEquals(eng.evaluate("RegExp.prototype")), true);
 
-    QCOMPARE(qjsvalue_cast<QRegExp>(rexp).pattern(), QRegExp("foo").pattern());
+        QCOMPARE(qjsvalue_cast<QRegExp>(rexp).pattern(), QRegExp("foo").pattern());
+    }
 }
 
 void tst_QJSEngine::jsRegExp()
@@ -1601,6 +1609,28 @@ void tst_QJSEngine::valueConversion_regExp()
     }
 }
 
+void tst_QJSEngine::valueConversion_RegularExpression()
+{
+    QJSEngine eng;
+    {
+        QRegularExpression in = QRegularExpression("foo");
+        QJSValue val = eng.toScriptValue(in);
+        QVERIFY(val.isRegExp());
+        QRegularExpression out = qjsvalue_cast<QRegularExpression>(val);
+        QCOMPARE(out.pattern(), in.pattern());
+        QCOMPARE(out.patternOptions(), in.patternOptions());
+    }
+    {
+        QRegularExpression in = QRegularExpression("foo",
+                                                   QRegularExpression::CaseInsensitiveOption);
+        QJSValue val = eng.toScriptValue(in);
+        QVERIFY(val.isRegExp());
+        QCOMPARE(qjsvalue_cast<QRegularExpression>(val), in);
+        QRegularExpression out = qjsvalue_cast<QRegularExpression>(val);
+        QCOMPARE(out.patternOptions(), in.patternOptions());
+    }
+}
+
 Q_DECLARE_METATYPE(QGradient)
 Q_DECLARE_METATYPE(QGradient*)
 Q_DECLARE_METATYPE(QLinearGradient)
@@ -2950,6 +2980,8 @@ void tst_QJSEngine::reentrancy_objectCreation()
         QJSValue r2 = eng2.evaluate("new RegExp('foo', 'gim')");
         QCOMPARE(qjsvalue_cast<QRegExp>(r1), qjsvalue_cast<QRegExp>(r2));
         QCOMPARE(qjsvalue_cast<QRegExp>(r2), qjsvalue_cast<QRegExp>(r1));
+        QCOMPARE(qjsvalue_cast<QRegularExpression>(r1), qjsvalue_cast<QRegularExpression>(r2));
+        QCOMPARE(qjsvalue_cast<QRegularExpression>(r2), qjsvalue_cast<QRegularExpression>(r1));
     }
     {
         QJSValue o1 = eng1.newQObject(temp);
@@ -3145,6 +3177,56 @@ void tst_QJSEngine::qRegExpInport()
     }
 }
 
+void tst_QJSEngine::qRegularExpressionImport_data()
+{
+    QTest::addColumn<QRegularExpression>("rx");
+    QTest::addColumn<QString>("string");
+    QTest::addColumn<QString>("matched");
+
+    QTest::newRow("normal")            << QRegularExpression("(test|foo)") << "test _ foo _ test _ Foo";
+    QTest::newRow("normal2")           << QRegularExpression("(Test|Foo)") << "test _ foo _ test _ Foo";
+    QTest::newRow("case insensitive")  << QRegularExpression("(test|foo)", QRegularExpression::CaseInsensitiveOption) << "test _ foo _ test _ Foo";
+    QTest::newRow("case insensitive2") << QRegularExpression("(Test|Foo)", QRegularExpression::CaseInsensitiveOption) << "test _ foo _ test _ Foo";
+    QTest::newRow("b(a*)(b*)")         << QRegularExpression("b(a*)(b*)", QRegularExpression::CaseInsensitiveOption) << "aaabbBbaAabaAaababaaabbaaab";
+    QTest::newRow("greedy")            << QRegularExpression("a*(a*)", QRegularExpression::CaseInsensitiveOption) << "aaaabaaba";
+    QTest::newRow("wildcard")          << QRegularExpression(".*\\.txt") << "file.txt";
+    QTest::newRow("wildcard 2")        << QRegularExpression("a.b\\.txt") << "ab.txt abb.rtc acb.txt";
+    QTest::newRow("slash")             << QRegularExpression("g/.*/s", QRegularExpression::CaseInsensitiveOption) << "string/string/string";
+    QTest::newRow("slash2")            << QRegularExpression("g / .* / s", QRegularExpression::CaseInsensitiveOption) << "string / string / string";
+    QTest::newRow("fixed")             << QRegularExpression("a\\*aa\\.a\\(ba\\)\\*a\\\\ba", QRegularExpression::CaseInsensitiveOption) << "aa*aa.a(ba)*a\\ba";
+    QTest::newRow("fixed insensitive") << QRegularExpression("A\\*A", QRegularExpression::CaseInsensitiveOption) << "a*A A*a A*A a*a";
+    QTest::newRow("fixed sensitive")   << QRegularExpression("A\\*A") << "a*A A*a A*A a*a";
+    QTest::newRow("html")              << QRegularExpression("<b>(.*)</b>") << "<b>bold</b><i>italic</i><b>bold</b>";
+    QTest::newRow("html minimal")      << QRegularExpression("^<b>(.*)</b>$") << "<b>bold</b><i>italic</i><b>bold</b>";
+    QTest::newRow("aaa")               << QRegularExpression("a{2,5}") << "aAaAaaaaaAa";
+    QTest::newRow("aaa minimal")       << QRegularExpression("^a{2,5}$") << "aAaAaaaaaAa";
+    QTest::newRow("minimal")           << QRegularExpression("^.*\\} [*8]$") << "}?} ?} *";
+    QTest::newRow(".? minimal")        << QRegularExpression("^.?$") << ".?";
+    QTest::newRow(".+ minimal")        << QRegularExpression("^.+$") << ".+";
+    QTest::newRow("[.?] minimal")      << QRegularExpression("^[.?]$") << ".?";
+    QTest::newRow("[.+] minimal")      << QRegularExpression("^[.+]$") << ".+";
+}
+
+void tst_QJSEngine::qRegularExpressionImport()
+{
+    QFETCH(QRegularExpression, rx);
+    QFETCH(QString, string);
+
+    QJSEngine eng;
+    QJSValue rexp;
+    rexp = eng.toScriptValue(rx);
+
+    QCOMPARE(rexp.isRegExp(), true);
+    QCOMPARE(rexp.isCallable(), false);
+
+    QJSValue func = eng.evaluate("(function(string, regexp) { return string.match(regexp); })");
+    QJSValue result = func.call(QJSValueList() << string << rexp);
+
+    const QRegularExpressionMatch match = rx.match(string);
+    for (int i = 0; i <= match.lastCapturedIndex(); i++)
+        QCOMPARE(result.property(i).toString(), match.captured(i));
+}
+
 // QScriptValue::toDateTime() returns a local time, whereas JS dates
 // are always stored as UTC. Qt Script must respect the current time
 // zone, and correctly adjust for daylight saving time that may be in
diff --git a/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp b/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
index b58cd98d1e..21ebf6b10b 100644
--- a/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
+++ b/tests/auto/qml/qjsvalue/tst_qjsvalue.cpp
@@ -1027,6 +1027,20 @@ void tst_QJSValue::toVariant()
         QJSValue rxObject = eng.toScriptValue(rx);
         QVERIFY(rxObject.isRegExp());
         QVariant var = rxObject.toVariant();
+
+        // We can't roundtrip a QRegExp this way, as toVariant() has no information on whether we
+        // want QRegExp or QRegularExpression. It will always create a QRegularExpression.
+        QCOMPARE(var.type(), QMetaType::QRegularExpression);
+        QRegularExpression result = var.toRegularExpression();
+        QCOMPARE(result.pattern(), rx.pattern());
+        QCOMPARE(result.patternOptions() & QRegularExpression::CaseInsensitiveOption, 0);
+    }
+
+    {
+        QRegularExpression rx = QRegularExpression("[0-9a-z]+");
+        QJSValue rxObject = eng.toScriptValue(rx);
+        QVERIFY(rxObject.isRegExp());
+        QVariant var = rxObject.toVariant();
         QCOMPARE(var, QVariant(rx));
     }
 
@@ -1194,6 +1208,32 @@ void tst_QJSValue::toRegExp()
     QVERIFY(qjsvalue_cast<QRegExp>(eng.toScriptValue(QVariant())).isEmpty());
 }
 
+void tst_QJSValue::toRegularExpression()
+{
+    QJSEngine eng;
+    {
+        QRegularExpression rx = qjsvalue_cast<QRegularExpression>(eng.evaluate("/foo/"));
+        QVERIFY(rx.isValid());
+        QCOMPARE(rx.pattern(), QString::fromLatin1("foo"));
+        QVERIFY(!(rx.patternOptions() & QRegularExpression::CaseInsensitiveOption));
+    }
+    {
+        QRegularExpression rx = qjsvalue_cast<QRegularExpression>(eng.evaluate("/bar/gi"));
+        QVERIFY(rx.isValid());
+        QCOMPARE(rx.pattern(), QString::fromLatin1("bar"));
+        QVERIFY(rx.patternOptions() & QRegularExpression::CaseInsensitiveOption);
+    }
+
+    QVERIFY(qjsvalue_cast<QRegularExpression>(eng.evaluate("[]")).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(eng.evaluate("{}")).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(eng.globalObject()).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(QJSValue()).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(QJSValue(123)).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(QJSValue(false)).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(eng.evaluate("null")).pattern().isEmpty());
+    QVERIFY(qjsvalue_cast<QRegularExpression>(eng.toScriptValue(QVariant())).pattern().isEmpty());
+}
+
 void tst_QJSValue::isArray_data()
 {
     newEngine();
diff --git a/tests/auto/qml/qjsvalue/tst_qjsvalue.h b/tests/auto/qml/qjsvalue/tst_qjsvalue.h
index b8b9f4403c..9532b1f10e 100644
--- a/tests/auto/qml/qjsvalue/tst_qjsvalue.h
+++ b/tests/auto/qml/qjsvalue/tst_qjsvalue.h
@@ -76,6 +76,7 @@ private slots:
     void toQObject();
     void toDateTime();
     void toRegExp();
+    void toRegularExpression();
     void isArray_data();
     void isArray();
     void isDate();
diff --git a/tests/auto/qml/qqmlecmascript/data/regularExpression.2.qml b/tests/auto/qml/qqmlecmascript/data/regularExpression.2.qml
new file mode 100644
index 0000000000..b22f8ab71e
--- /dev/null
+++ b/tests/auto/qml/qqmlecmascript/data/regularExpression.2.qml
@@ -0,0 +1,7 @@
+import Qt.test 1.0
+
+MyQmlObject{
+    id: obj
+    objectName: "obj"
+    regularExpression: "[a-zA-z]"
+}
diff --git a/tests/auto/qml/qqmlecmascript/data/regularExpression.qml b/tests/auto/qml/qqmlecmascript/data/regularExpression.qml
new file mode 100644
index 0000000000..6f31ffd305
--- /dev/null
+++ b/tests/auto/qml/qqmlecmascript/data/regularExpression.qml
@@ -0,0 +1,7 @@
+import Qt.test 1.0
+
+MyQmlObject{
+    id: obj
+    objectName: "obj"
+    regularExpression: /[a-zA-z]/
+}
diff --git a/tests/auto/qml/qqmlecmascript/testtypes.h b/tests/auto/qml/qqmlecmascript/testtypes.h
index 4547a74470..32120ee5b7 100644
--- a/tests/auto/qml/qqmlecmascript/testtypes.h
+++ b/tests/auto/qml/qqmlecmascript/testtypes.h
@@ -33,6 +33,7 @@
 #include <QtQml/qqmlexpression.h>
 #include <QtCore/qpoint.h>
 #include <QtCore/qsize.h>
+#include <QtCore/qregularexpression.h>
 #include <QtQml/qqmllist.h>
 #include <QtCore/qrect.h>
 #include <QtGui/qmatrix.h>
@@ -101,6 +102,7 @@ class MyQmlObject : public QObject
     Q_PROPERTY(QQmlListProperty<QObject> objectListProperty READ objectListProperty CONSTANT)
     Q_PROPERTY(int resettableProperty READ resettableProperty WRITE setResettableProperty RESET resetProperty)
     Q_PROPERTY(QRegExp regExp READ regExp WRITE setRegExp)
+    Q_PROPERTY(QRegularExpression regularExpression READ regularExpression WRITE setRegularExpression)
     Q_PROPERTY(int nonscriptable READ nonscriptable WRITE setNonscriptable SCRIPTABLE false)
     Q_PROPERTY(int intProperty READ intProperty WRITE setIntProperty NOTIFY intChanged)
     Q_PROPERTY(QJSValue qjsvalue READ qjsvalue WRITE setQJSValue NOTIFY qjsvalueChanged)
@@ -170,6 +172,12 @@ public:
     QRegExp regExp() { return m_regExp; }
     void setRegExp(const QRegExp &regExp) { m_regExp = regExp; }
 
+    QRegularExpression regularExpression() { return m_regularExpression; }
+    void setRegularExpression(const QRegularExpression &regularExpression)
+    {
+        m_regularExpression = regularExpression;
+    }
+
     int console() const { return 11; }
 
     int nonscriptable() const { return 0; }
@@ -270,6 +278,7 @@ private:
     int m_value;
     int m_resetProperty;
     QRegExp m_regExp;
+    QRegularExpression m_regularExpression;
     QVariant m_variant;
     QJSValue m_qjsvalue;
     int m_intProperty;
diff --git a/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp b/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp
index 48cbf02751..b4349f79ca 100644
--- a/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp
+++ b/tests/auto/qml/qqmlecmascript/tst_qqmlecmascript.cpp
@@ -2418,6 +2418,13 @@ void tst_qqmlecmascript::regExpBug()
         delete object;
     }
 
+    {
+        QQmlComponent component(&engine, testFileUrl("regularExpression.qml"));
+        QScopedPointer<MyQmlObject> object(qobject_cast<MyQmlObject*>(component.create()));
+        QVERIFY(!object.isNull());
+        QCOMPARE(object->regularExpression().pattern(), QLatin1String("[a-zA-z]"));
+    }
+
     //QTBUG-23068
     {
         QString err = QString(QLatin1String("%1:6 Invalid property assignment: regular expression expected; use /pattern/ syntax\n")).arg(testFileUrl("regExp.2.qml").toString());
@@ -2427,6 +2434,18 @@ void tst_qqmlecmascript::regExpBug()
         QVERIFY(!object);
         QCOMPARE(component.errorString(), err);
     }
+
+    {
+        const QString err = QString::fromLatin1("%1:6 Invalid property assignment: "
+                                                "regular expression expected; "
+                                                "use /pattern/ syntax\n")
+                                    .arg(testFileUrl("regularExpression.2.qml").toString());
+        QQmlComponent component(&engine, testFileUrl("regularExpression.2.qml"));
+        QTest::ignoreMessage(QtWarningMsg, "QQmlComponent: Component is not ready");
+        MyQmlObject *object = qobject_cast<MyQmlObject*>(component.create());
+        QVERIFY(!object);
+        QCOMPARE(component.errorString(), err);
+    }
 }
 
 static inline bool evaluate_error(QV4::ExecutionEngine *v4, const QV4::Value &o, const char *source)
diff --git a/tests/auto/qml/qquickworkerscript/tst_qquickworkerscript.cpp b/tests/auto/qml/qquickworkerscript/tst_qquickworkerscript.cpp
index 4ad58ba56c..dfaeca67f1 100644
--- a/tests/auto/qml/qquickworkerscript/tst_qquickworkerscript.cpp
+++ b/tests/auto/qml/qquickworkerscript/tst_qquickworkerscript.cpp
@@ -30,6 +30,7 @@
 #include <QtCore/qtimer.h>
 #include <QtCore/qdir.h>
 #include <QtCore/qfileinfo.h>
+#include <QtCore/qregularexpression.h>
 #include <QtQml/qjsengine.h>
 
 #include <QtQml/qqmlcomponent.h>
@@ -118,7 +119,18 @@ void tst_QQuickWorkerScript::messaging()
     QVariant response = mo->property(mo->indexOfProperty("response")).read(worker).value<QVariant>();
     if (response.userType() == qMetaTypeId<QJSValue>())
         response = response.value<QJSValue>().toVariant();
-    QCOMPARE(response, value);
+
+    if (value.type() == QMetaType::QRegExp && response.type() == QMetaType::QRegularExpression) {
+        // toVariant() doesn't know if we want QRegExp or QRegularExpression. It always creates
+        // a QRegularExpression from a JavaScript regular expression.
+        const QRegularExpression responseRegExp = response.toRegularExpression();
+        const QRegExp valueRegExp = value.toRegExp();
+        QCOMPARE(responseRegExp.pattern(), valueRegExp.pattern());
+        QCOMPARE(bool(responseRegExp.patternOptions() & QRegularExpression::CaseInsensitiveOption),
+                 bool(valueRegExp.caseSensitivity() == Qt::CaseInsensitive));
+    } else {
+        QCOMPARE(response, value);
+    }
 
     qApp->processEvents();
     delete worker;
@@ -135,10 +147,10 @@ void tst_QQuickWorkerScript::messaging_data()
     QTest::newRow("string") << qVariantFromValue(QString("More cheeeese, Gromit!"));
     QTest::newRow("variant list") << qVariantFromValue((QVariantList() << "a" << "b" << "c"));
     QTest::newRow("date time") << qVariantFromValue(QDateTime::currentDateTime());
-#ifndef QT_NO_REGEXP
-    // Qt Script's QScriptValue -> QRegExp uses RegExp2 pattern syntax
-    QTest::newRow("regexp") << qVariantFromValue(QRegExp("^\\d\\d?$", Qt::CaseInsensitive, QRegExp::RegExp2));
-#endif
+    QTest::newRow("regexp") << qVariantFromValue(QRegExp("^\\d\\d?$", Qt::CaseInsensitive,
+                                                         QRegExp::RegExp2));
+    QTest::newRow("regularexpression") << qVariantFromValue(QRegularExpression(
+            "^\\d\\d?$", QRegularExpression::CaseInsensitiveOption));
 }
 
 void tst_QQuickWorkerScript::messaging_sendQObjectList()