Long live Qt5 meta-object method/property descriptors

This commit introduces two significant changes to the meta-object
data format:

1) Meta-type information (QMetaType type/name) information is
stored directly in the meta-data for both properties and methods;
2) The original signature (string) of a method is no longer stored
in the meta-data, since it can be reconstructed from the method
name and parameter type info.

The motivation for this change is to enable direct access to method
names and type information (avoiding string-based lookup for types
if possible), since that's typically the information language
bindings (e.g. QML) need. (moc already had all the desired
information about methods, but it threw it away!)

This change keeps support for the older (6 and below) meta-object
revisions, but the support will be removed after a short grace
period.

The following public QMetaMethod functions have been added:

name() : QByteArray
returnType() : int
parameterCount() : int
parameterType(int index) : int

The following internal QMetaMethod function has been added:

getParameterTypes(int *types) : void

This commit extends the meta-method data to include explicit
type/name data for methods. The new data follows the existing
(5-word) method descriptors in the meta-data. The method descriptor
format was modified to enable this. First, the descriptor now
contains the meta-data index where the method's type/name information
can be found. Second, the descriptor contains the number of
parameters. Third, the descriptor has a reference to the name of the
method, not the full signature.

Each entry of a method's type/name array contains either the type id
(if it could be determined at meta-object definition time), or a
reference to the name of the type (so that the type id can be
resolved at runtime).

Lastly, instead of storing the method parameter names as a
comma-separated list that needs to be parsed at runtime (which was
how it was done prior to this commit), the names are now stored as
separate entries in the meta-object string table, and their indexes
are stored immediately after the method type info array. Hence,
parameter names can be queried through the public API without
parsing/allocating/copying, too.

Task-number: QTBUG-24154
Change-Id: Idb7ab81f12d4bfd658b74e18a0fce594f580cba3
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>

1 files changed, 171 insertions, 44 deletions

diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp
index f44e4c4761..9977f96f99 100644
--- a/src/corelib/kernel/qobject.cpp
+++ b/src/corelib/kernel/qobject.cpp
@@ -95,6 +95,30 @@ static int *queuedConnectionTypes(const QList<QByteArray> &typeNames)
     return types;
 }
 
+static int *queuedConnectionTypes(const QArgumentType *argumentTypes, int argc)
+{
+    QScopedArrayPointer<int> types(new int [argc + 1]);
+    for (int i = 0; i < argc; ++i) {
+        const QArgumentType &type = argumentTypes[i];
+        if (type.type())
+            types[i] = type.type();
+        else if (type.name().endsWith('*'))
+            types[i] = QMetaType::VoidStar;
+        else
+            types[i] = QMetaType::type(type.name());
+
+        if (!types[i]) {
+            qWarning("QObject::connect: Cannot queue arguments of type '%s'\n"
+                     "(Make sure '%s' is registered using qRegisterMetaType().)",
+                     type.name().constData(), type.name().constData());
+            return 0;
+        }
+    }
+    types[argc] = 0;
+
+    return types.take();
+}
+
 static QBasicMutex _q_ObjectMutexPool[131];
 
 /** \internal
@@ -2278,20 +2302,40 @@ QMetaObject::Connection QObject::connect(const QObject *sender, const char *sign
     const QMetaObject *smeta = sender->metaObject();
     const char *signal_arg = signal;
     ++signal; //skip code
-    int signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);
-    if (signal_index < 0) {
-        // check for normalized signatures
-        tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);
-        signal = tmp_signal_name.constData() + 1;
-
-        smeta = sender->metaObject();
+    QByteArray signalName;
+    QArgumentTypeArray signalTypes;
+    int signal_index;
+    if (QMetaObjectPrivate::get(smeta)->revision >= 7) {
+        signalName = QMetaObjectPrivate::decodeMethodSignature(signal, signalTypes);
+        signal_index = QMetaObjectPrivate::indexOfSignalRelative(
+                &smeta, signalName, signalTypes.size(), signalTypes.constData());
+        if (signal_index < 0) {
+            // check for normalized signatures
+            tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);
+            signal = tmp_signal_name.constData() + 1;
+
+            signalTypes.clear();
+            signalName = QMetaObjectPrivate::decodeMethodSignature(signal, signalTypes);
+            smeta = sender->metaObject();
+            signal_index = QMetaObjectPrivate::indexOfSignalRelative(
+                    &smeta, signalName, signalTypes.size(), signalTypes.constData());
+        }
+    } else {
         signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);
-    }
-    if (signal_index < 0) {
-        // re-use tmp_signal_name and signal from above
+        if (signal_index < 0) {
+            // check for normalized signatures
+            tmp_signal_name = QMetaObject::normalizedSignature(signal - 1);
+            signal = tmp_signal_name.constData() + 1;
+
+            smeta = sender->metaObject();
+            signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);
+            if (signal_index < 0) {
+                // re-use tmp_signal_name and signal from above
 
-        smeta = sender->metaObject();
-        signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, true);
+                smeta = sender->metaObject();
+                signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, true);
+            }
+        }
     }
     if (signal_index < 0) {
         err_method_notfound(sender, signal_arg, "connect");
@@ -2312,36 +2356,71 @@ QMetaObject::Connection QObject::connect(const QObject *sender, const char *sign
     const char *method_arg = method;
     ++method; // skip code
 
+    QByteArray methodName;
+    QArgumentTypeArray methodTypes;
     const QMetaObject *rmeta = receiver->metaObject();
     int method_index_relative = -1;
-    switch (membcode) {
-    case QSLOT_CODE:
-        method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, false);
-        break;
-    case QSIGNAL_CODE:
-        method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, false);
-        break;
-    }
-
-    if (method_index_relative < 0) {
-        // check for normalized methods
-        tmp_method_name = QMetaObject::normalizedSignature(method);
-        method = tmp_method_name.constData();
-
-        // rmeta may have been modified above
-        rmeta = receiver->metaObject();
+    if (QMetaObjectPrivate::get(rmeta)->revision >= 7) {
+        switch (membcode) {
+        case QSLOT_CODE:
+            method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(
+                    &rmeta, methodName, methodTypes.size(), methodTypes.constData());
+            break;
+        case QSIGNAL_CODE:
+            method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(
+                    &rmeta, methodName, methodTypes.size(), methodTypes.constData());
+            break;
+        }
+        if (method_index_relative < 0) {
+            // check for normalized methods
+            tmp_method_name = QMetaObject::normalizedSignature(method);
+            method = tmp_method_name.constData();
+
+            methodTypes.clear();
+            methodName = QMetaObjectPrivate::decodeMethodSignature(method, methodTypes);
+            // rmeta may have been modified above
+            rmeta = receiver->metaObject();
+            switch (membcode) {
+            case QSLOT_CODE:
+                method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(
+                        &rmeta, methodName, methodTypes.size(), methodTypes.constData());
+                break;
+            case QSIGNAL_CODE:
+                method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(
+                        &rmeta, methodName, methodTypes.size(), methodTypes.constData());
+                break;
+            }
+        }
+    } else {
         switch (membcode) {
         case QSLOT_CODE:
             method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, false);
-            if (method_index_relative < 0)
-                method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, true);
             break;
         case QSIGNAL_CODE:
             method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, false);
-            if (method_index_relative < 0)
-                method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, true);
             break;
         }
+
+        if (method_index_relative < 0) {
+            // check for normalized methods
+            tmp_method_name = QMetaObject::normalizedSignature(method);
+            method = tmp_method_name.constData();
+
+            // rmeta may have been modified above
+            rmeta = receiver->metaObject();
+            switch (membcode) {
+            case QSLOT_CODE:
+                method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, false);
+                if (method_index_relative < 0)
+                    method_index_relative = QMetaObjectPrivate::indexOfSlotRelative(&rmeta, method, true);
+                break;
+            case QSIGNAL_CODE:
+                method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, false);
+                if (method_index_relative < 0)
+                    method_index_relative = QMetaObjectPrivate::indexOfSignalRelative(&rmeta, method, true);
+                break;
+            }
+        }
     }
 
     if (method_index_relative < 0) {
@@ -2350,7 +2429,18 @@ QMetaObject::Connection QObject::connect(const QObject *sender, const char *sign
         return QMetaObject::Connection(0);
     }
 
-    if (!QMetaObject::checkConnectArgs(signal, method)) {
+    bool compatibleArgs = true;
+    if ((QMetaObjectPrivate::get(smeta)->revision < 7) && (QMetaObjectPrivate::get(rmeta)->revision < 7)) {
+        compatibleArgs = QMetaObject::checkConnectArgs(signal, method);
+    } else {
+        if (signalName.isEmpty())
+            signalName = QMetaObjectPrivate::decodeMethodSignature(signal, signalTypes);
+        if (methodName.isEmpty())
+            methodName = QMetaObjectPrivate::decodeMethodSignature(method, methodTypes);
+        compatibleArgs = QMetaObjectPrivate::checkConnectArgs(signalTypes.size(), signalTypes.constData(),
+                                                              methodTypes.size(), methodTypes.constData());
+    }
+    if (!compatibleArgs) {
         qWarning("QObject::connect: Incompatible sender/receiver arguments"
                  "\n        %s::%s --> %s::%s",
                  sender->metaObject()->className(), signal,
@@ -2360,8 +2450,11 @@ QMetaObject::Connection QObject::connect(const QObject *sender, const char *sign
 
     int *types = 0;
     if ((type == Qt::QueuedConnection)
-            && !(types = queuedConnectionTypes(smeta->method(signal_absolute_index).parameterTypes())))
+        && ((QMetaObjectPrivate::get(smeta)->revision >= 7)
+        ? !(types = queuedConnectionTypes(signalTypes.constData(), signalTypes.size()))
+            : !(types = queuedConnectionTypes(smeta->method(signal_absolute_index).parameterTypes())))) {
         return QMetaObject::Connection(0);
+    }
 
 #ifndef QT_NO_DEBUG
     if (warnCompat) {
@@ -2604,12 +2697,25 @@ bool QObject::disconnect(const QObject *sender, const char *signal,
     */
     bool res = false;
     const QMetaObject *smeta = sender->metaObject();
+    QByteArray signalName;
+    QArgumentTypeArray signalTypes;
+    if (signal && (QMetaObjectPrivate::get(smeta)->revision >= 7))
+        signalName = QMetaObjectPrivate::decodeMethodSignature(signal, signalTypes);
+    QByteArray methodName;
+    QArgumentTypeArray methodTypes;
+    if (method && (QMetaObjectPrivate::get(receiver->metaObject())->revision >= 7))
+        methodName = QMetaObjectPrivate::decodeMethodSignature(method, methodTypes);
     do {
         int signal_index = -1;
         if (signal) {
-            signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);
-            if (signal_index < 0)
-                signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, true);
+            if (QMetaObjectPrivate::get(smeta)->revision >= 7) {
+                signal_index = QMetaObjectPrivate::indexOfSignalRelative(
+                            &smeta, signalName, signalTypes.size(), signalTypes.constData());
+            } else {
+                signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, false);
+                if (signal_index < 0)
+                    signal_index = QMetaObjectPrivate::indexOfSignalRelative(&smeta, signal, true);
+            }
             if (signal_index < 0)
                 break;
             signal_index = QMetaObjectPrivate::originalClone(smeta, signal_index);
@@ -2624,7 +2730,13 @@ bool QObject::disconnect(const QObject *sender, const char *signal,
         } else {
             const QMetaObject *rmeta = receiver->metaObject();
             do {
-                int method_index = rmeta->indexOfMethod(method);
+                int method_index;
+                if (QMetaObjectPrivate::get(rmeta)->revision >= 7) {
+                    method_index = QMetaObjectPrivate::indexOfMethod(
+                            rmeta, methodName, methodTypes.size(), methodTypes.constData());
+                } else {
+                    method_index = rmeta->indexOfMethod(method);
+                }
                 if (method_index >= 0)
                     while (method_index < rmeta->methodOffset())
                             rmeta = rmeta->superClass();
@@ -3307,9 +3419,17 @@ int QObjectPrivate::signalIndex(const char *signalName) const
 {
     Q_Q(const QObject);
     const QMetaObject *base = q->metaObject();
-    int relative_index = QMetaObjectPrivate::indexOfSignalRelative(&base, signalName, false);
-    if (relative_index < 0)
-        relative_index = QMetaObjectPrivate::indexOfSignalRelative(&base, signalName, true);
+    int relative_index;
+    if (QMetaObjectPrivate::get(base)->revision >= 7) {
+        QArgumentTypeArray types;
+        QByteArray name = QMetaObjectPrivate::decodeMethodSignature(signalName, types);
+        relative_index = QMetaObjectPrivate::indexOfSignalRelative(
+                &base, name, types.size(), types.constData());
+    } else {
+        relative_index = QMetaObjectPrivate::indexOfSignalRelative(&base, signalName, false);
+        if (relative_index < 0)
+            relative_index = QMetaObjectPrivate::indexOfSignalRelative(&base, signalName, true);
+    }
     if (relative_index < 0)
         return relative_index;
     relative_index = QMetaObjectPrivate::originalClone(base, relative_index);
@@ -4037,9 +4157,16 @@ QMetaObject::Connection QObject::connectImpl(const QObject *sender, void **signa
     locker.unlock();
 
     // reconstruct the signature to call connectNotify
-    const char *sig = QMetaObjectPrivate::rawStringData(senderMetaObject, senderMetaObject->d.data[
-        reinterpret_cast<const QMetaObjectPrivate*>(senderMetaObject->d.data)->methodData
-            + 5 * (signal_index - signalOffset)]);
+    QByteArray tmp_sig;
+    const char *sig;
+    if (QMetaObjectPrivate::get(senderMetaObject)->revision >= 7) {
+        tmp_sig = senderMetaObject->method(signal_index - signalOffset + methodOffset).methodSignature();
+        sig = tmp_sig.constData();
+    } else {
+        sig = reinterpret_cast<const char *>(senderMetaObject->d.stringdata)
+              + senderMetaObject->d.data[QMetaObjectPrivate::get(senderMetaObject)->methodData
+                                         + 5 * (signal_index - signalOffset)];
+    }
     QVarLengthArray<char> signalSignature(qstrlen(sig) + 2);
     signalSignature.data()[0] = char(QSIGNAL_CODE + '0');
     strcpy(signalSignature.data() + 1 , sig);