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>

6 files changed, 80 insertions, 3 deletions

diff --git a/src/qml/compiler/qqmlpropertyvalidator.cpp b/src/qml/compiler/qqmlpropertyvalidator.cpp
index 1beaac8095..4714f505a7 100644
--- a/src/qml/compiler/qqmlpropertyvalidator.cpp
+++ b/src/qml/compiler/qqmlpropertyvalidator.cpp
@@ -558,6 +558,7 @@ QQmlCompileError QQmlPropertyValidator::validateLiteralBinding(QQmlPropertyCache
     }
     break;
     case QVariant::RegExp:
+    case QVariant::RegularExpression:
         return warnOrError(tr("Invalid property assignment: regular expression expected; use /pattern/ syntax"));
     default: {
         // generate single literal value assignment to a list property if required
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 8adb84719f..02cb9cae62 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -51,6 +51,9 @@
 #include <QDir>
 #include <QFileInfo>
 #include <QLoggingCategory>
+#if QT_CONFIG(regularexpression)
+#include <QRegularExpression>
+#endif
 
 #ifndef V4_BOOTSTRAP
 
@@ -854,6 +857,13 @@ Heap::RegExpObject *ExecutionEngine::newRegExpObject(const QRegExp &re)
     return memoryManager->allocate<RegExpObject>(re);
 }
 
+#if QT_CONFIG(regularexpression)
+Heap::RegExpObject *ExecutionEngine::newRegExpObject(const QRegularExpression &re)
+{
+    return memoryManager->allocate<RegExpObject>(re);
+}
+#endif
+
 Heap::Object *ExecutionEngine::newErrorObject(const Value &value)
 {
     return ErrorObject::create<ErrorObject>(this, value, errorCtor());
@@ -1365,8 +1375,13 @@ static QVariant toVariant(QV4::ExecutionEngine *e, const QV4::Value &value, int
     QV4::ScopedObject o(scope, value);
     Q_ASSERT(o);
 
-    if (QV4::RegExpObject *re = o->as<QV4::RegExpObject>())
+    if (QV4::RegExpObject *re = o->as<QV4::RegExpObject>()) {
+#if QT_CONFIG(regularexpression)
+        if (typeHint != QMetaType::QRegExp)
+            return re->toQRegularExpression();
+#endif
         return re->toQRegExp();
+    }
 
     if (createJSValueForObjects)
         return QVariant::fromValue(QJSValue(scope.engine, o->asReturnedValue()));
@@ -1455,8 +1470,6 @@ static QV4::ReturnedValue objectFromVariantMap(QV4::ExecutionEngine *e, const QV
     return o.asReturnedValue();
 }
 
-Q_CORE_EXPORT QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
-
 QV4::ReturnedValue QV4::ExecutionEngine::fromVariant(const QVariant &variant)
 {
     int type = variant.userType();
@@ -1506,6 +1519,10 @@ QV4::ReturnedValue QV4::ExecutionEngine::fromVariant(const QVariant &variant)
                 return QV4::Encode(newDateObjectFromTime(*reinterpret_cast<const QTime *>(ptr)));
             case QMetaType::QRegExp:
                 return QV4::Encode(newRegExpObject(*reinterpret_cast<const QRegExp *>(ptr)));
+#if QT_CONFIG(regularexpression)
+            case QMetaType::QRegularExpression:
+                return QV4::Encode(newRegExpObject(*reinterpret_cast<const QRegularExpression *>(ptr)));
+#endif
             case QMetaType::QObjectStar:
                 return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(ptr));
 #if QT_CONFIG(qml_sequence_object)
@@ -1713,6 +1730,10 @@ QV4::ReturnedValue ExecutionEngine::metaTypeToJS(int type, const void *data)
         return QV4::Encode(newDateObject(QDateTime(*reinterpret_cast<const QDate *>(data))));
     case QMetaType::QRegExp:
         return QV4::Encode(newRegExpObject(*reinterpret_cast<const QRegExp *>(data)));
+#if QT_CONFIG(regularexpression)
+    case QMetaType::QRegularExpression:
+        return QV4::Encode(newRegExpObject(*reinterpret_cast<const QRegularExpression *>(data)));
+#endif
     case QMetaType::QObjectStar:
         return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(data));
     case QMetaType::QVariant:
@@ -1955,6 +1976,13 @@ bool ExecutionEngine::metaTypeFromJS(const Value *value, int type, void *data)
             *reinterpret_cast<QRegExp *>(data) = r->toQRegExp();
             return true;
         } break;
+#if QT_CONFIG(regularexpression)
+    case QMetaType::QRegularExpression:
+        if (const QV4::RegExpObject *r = value->as<QV4::RegExpObject>()) {
+            *reinterpret_cast<QRegularExpression *>(data) = r->toQRegularExpression();
+            return true;
+        } break;
+#endif
     case QMetaType::QObjectStar: {
         const QV4::QObjectWrapper *qobjectWrapper = value->as<QV4::QObjectWrapper>();
         if (qobjectWrapper || value->isNull()) {
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 4557f623d0..3735c24601 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -520,6 +520,9 @@ public:
     Heap::RegExpObject *newRegExpObject(const QString &pattern, int flags);
     Heap::RegExpObject *newRegExpObject(RegExp *re);
     Heap::RegExpObject *newRegExpObject(const QRegExp &re);
+#if QT_CONFIG(regularexpression)
+    Heap::RegExpObject *newRegExpObject(const QRegularExpression &re);
+#endif
 
     Heap::Object *newErrorObject(const Value &value);
     Heap::Object *newErrorObject(const QString &message);
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 355dcffaf7..15f064ba7a 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -1317,6 +1317,9 @@ static int MatchScore(const QV4::Value &actual, int conversionType)
     } else if (actual.as<QV4::RegExpObject>()) {
         switch (conversionType) {
         case QMetaType::QRegExp:
+#if QT_CONFIG(regularexpression)
+        case QMetaType::QRegularExpression:
+#endif
             return 0;
         default:
             return 10;
diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp
index 39a2e96b45..5bd25dcbec 100644
--- a/src/qml/jsruntime/qv4regexpobject.cpp
+++ b/src/qml/jsruntime/qv4regexpobject.cpp
@@ -50,6 +50,9 @@
 
 #include <QtCore/QDebug>
 #include <QtCore/qregexp.h>
+#if QT_CONFIG(regularexpression)
+#include <QtCore/qregularexpression.h>
+#endif
 #include <cassert>
 #include <typeinfo>
 #include <iostream>
@@ -134,6 +137,25 @@ void Heap::RegExpObject::init(const QRegExp &re)
     o->initProperties();
 }
 
+#if QT_CONFIG(regularexpression)
+// Converts a QRegularExpression to a JS RegExp.
+// The conversion is not 100% exact since ECMA regexp and QRegularExpression
+// have different semantics/flags, but we try to do our best.
+void Heap::RegExpObject::init(const QRegularExpression &re)
+{
+    Object::init();
+
+    Scope scope(internalClass->engine);
+    Scoped<QV4::RegExpObject> o(scope, this);
+
+    const uint flags = (re.patternOptions() & QRegularExpression::CaseInsensitiveOption)
+            ? CompiledData::RegExp::RegExp_IgnoreCase
+            : CompiledData::RegExp::RegExp_NoFlags;
+    o->d()->value.set(scope.engine, QV4::RegExp::create(scope.engine, re.pattern(), flags));
+    o->initProperties();
+}
+#endif
+
 void RegExpObject::initProperties()
 {
     setProperty(Index_LastIndex, Value::fromInt32(0));
@@ -150,6 +172,20 @@ QRegExp RegExpObject::toQRegExp() const
     return QRegExp(*value()->pattern, caseSensitivity, QRegExp::RegExp2);
 }
 
+#if QT_CONFIG(regularexpression)
+// Converts a JS RegExp to a QRegularExpression.
+// The conversion is not 100% exact since ECMA regexp and QRegularExpression
+// have different semantics/flags, but we try to do our best.
+QRegularExpression RegExpObject::toQRegularExpression() const
+{
+    QRegularExpression::PatternOptions caseSensitivity
+            = (value()->flags & CompiledData::RegExp::RegExp_IgnoreCase)
+            ? QRegularExpression::CaseInsensitiveOption
+            : QRegularExpression::NoPatternOption;
+    return QRegularExpression(*value()->pattern, caseSensitivity);
+}
+#endif
+
 QString RegExpObject::toString() const
 {
     QString p = *value()->pattern;
diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h
index a584404c0b..04b533e49d 100644
--- a/src/qml/jsruntime/qv4regexpobject_p.h
+++ b/src/qml/jsruntime/qv4regexpobject_p.h
@@ -81,6 +81,9 @@ DECLARE_HEAP_OBJECT(RegExpObject, Object) {
     void init();
     void init(QV4::RegExp *value);
     void init(const QRegExp &re);
+#if QT_CONFIG(regularexpression)
+    void init(const QRegularExpression &re);
+#endif
 };
 
 #define RegExpCtorMembers(class, Member) \
@@ -138,6 +141,9 @@ struct RegExpObject: Object {
     }
 
     QRegExp toQRegExp() const;
+#if QT_CONFIG(regularexpression)
+    QRegularExpression toQRegularExpression() const;
+#endif
     QString toString() const;
     QString source() const;