Improve rejection messages

In AbstractMetaBuilderPrivate::traverseFunction(), store the
unmodified signature with return type before resolving typedefs for
the messages. Extend the error messages about parameters and output
them to qWarning() and rejection logs consistently.

So:

Unmatched argument type
 - QOpenGLExtraFunctions::glIsSync(GLsync) -> GLboolean

becomes:

Unmatched argument type
 - GLboolean QOpenGLExtraFunctions::glIsSync(GLsync): unmatched type 'GLsync' in parameter #1 "sync"

Task-number: PYSIDE-516
Change-Id: Ifd680af1cd6d403d9b73ba3e40d06abe274cf359
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

1 files changed, 44 insertions, 23 deletions

diff --git a/ApiExtractor/abstractmetabuilder.cpp b/ApiExtractor/abstractmetabuilder.cpp
index 31c78ce..ef6a480 100644
--- a/ApiExtractor/abstractmetabuilder.cpp
+++ b/ApiExtractor/abstractmetabuilder.cpp
@@ -2038,16 +2038,35 @@ static QString functionSignature(FunctionModelItem functionItem)
     return functionItem->name() + QLatin1Char('(') + args.join(QLatin1Char(',')) + QLatin1Char(')');
 }
 
-static inline QString functionSignatureWithReturnType(FunctionModelItem functionItem)
+static inline QString qualifiedFunctionSignatureWithType(const FunctionModelItem &functionItem,
+                                                         const QString &className = QString())
 {
-    return functionSignature(functionItem)
-            + QStringLiteral(" -> ") + functionItem->type().toString();
+    QString result = functionItem->type().toString() + QLatin1Char(' ');
+    if (!className.isEmpty())
+        result += className + colonColon();
+    result += functionSignature(functionItem);
+    return result;
 }
 
-static inline QString qualifiedFunctionSignatureWithType(const QString &className,
-                                                  FunctionModelItem functionItem)
+static inline QString msgUnmatchedParameterType(const ArgumentModelItem &arg, int n)
 {
-    return className + colonColon() + functionSignatureWithReturnType(functionItem);
+    QString result;
+    QTextStream str(&result);
+    str << "unmatched type '" << arg->type().toString() << "' in parameter #"
+        << (n + 1);
+    if (!arg->name().isEmpty())
+        str << " \"" << arg->name() << '"';
+    return result;
+}
+
+static inline QString msgVoidParameterType(const ArgumentModelItem &arg, int n)
+{
+    QString result;
+    QTextStream str(&result);
+    str << "'void' encountered at parameter #" << (n + 1);
+    if (!arg->name().isEmpty())
+        str << " \"" << arg->name() << '"';
+    return result;
 }
 
 AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModelItem functionItem)
@@ -2056,7 +2075,6 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
         return nullptr;
     QString functionName = functionItem->name();
     QString className;
-    QString rejectedFunctionSignature;
     if (m_currentClass) {
         // Clang: Skip qt_metacast(), qt_metacall(), expanded from Q_OBJECT
         // and overridden metaObject(), QGADGET helpers
@@ -2069,15 +2087,17 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
             return nullptr;
     }
 
+    // Store original signature with unresolved typedefs for message/log purposes
+    const QString originalQualifiedSignatureWithReturn =
+        qualifiedFunctionSignatureWithType(functionItem, className);
+
     if (TypeDatabase::instance()->isFunctionRejected(className, functionName)) {
-        rejectedFunctionSignature = qualifiedFunctionSignatureWithType(className, functionItem);
-        m_rejectedFunctions.insert(rejectedFunctionSignature, AbstractMetaBuilder::GenerationDisabled);
+        m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn, AbstractMetaBuilder::GenerationDisabled);
         return 0;
     }
     else if (TypeDatabase::instance()->isFunctionRejected(className,
                                                           functionSignature(functionItem))) {
-        rejectedFunctionSignature = qualifiedFunctionSignatureWithType(className, functionItem);
-        m_rejectedFunctions.insert(rejectedFunctionSignature, AbstractMetaBuilder::GenerationDisabled);
+        m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn, AbstractMetaBuilder::GenerationDisabled);
         return 0;
     }
 
@@ -2144,11 +2164,10 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
         if (!ok) {
             Q_ASSERT(type == 0);
             qCWarning(lcShiboken).noquote().nospace()
-                << QStringLiteral("skipping function '%1::%2', unmatched return type '%3'")
-                                  .arg(className, functionItem->name(),
+                << QStringLiteral("skipping function '%1', unmatched return type '%2'")
+                                  .arg(originalQualifiedSignatureWithReturn,
                                        functionItem->type().toString());
-            rejectedFunctionSignature = qualifiedFunctionSignatureWithType(className, functionItem);
-            m_rejectedFunctions.insert(rejectedFunctionSignature, AbstractMetaBuilder::UnmatchedReturnType);
+            m_rejectedFunctions.insert(originalQualifiedSignatureWithReturn, AbstractMetaBuilder::UnmatchedReturnType);
             metaFunction->setInvalid(true);
             return metaFunction;
         }
@@ -2179,22 +2198,24 @@ AbstractMetaFunction *AbstractMetaBuilderPrivate::traverseFunction(FunctionModel
         AbstractMetaType* metaType = translateType(arg->type(), &ok);
         if (!ok) {
             Q_ASSERT(metaType == 0);
+            const QString reason = msgUnmatchedParameterType(arg, i);
             qCWarning(lcShiboken).noquote().nospace()
-                << QStringLiteral("skipping function '%1::%2', unmatched parameter type '%3'")
-                                  .arg(className, functionItem->name(), arg->type().toString());
-            rejectedFunctionSignature = qualifiedFunctionSignatureWithType(className, functionItem);
+                << QStringLiteral("skipping function '%1', %2")
+                                  .arg(originalQualifiedSignatureWithReturn, reason);
+            const QString rejectedFunctionSignature = originalQualifiedSignatureWithReturn
+                + QLatin1String(": ") + reason;
             m_rejectedFunctions.insert(rejectedFunctionSignature, AbstractMetaBuilder::UnmatchedArgumentType);
             metaFunction->setInvalid(true);
             return metaFunction;
         }
 
         if (metaType == Q_NULLPTR) {
+            const QString reason = msgVoidParameterType(arg, i);
             qCWarning(lcShiboken).noquote().nospace()
-                << QString::fromLatin1("skipping function '%1::%2', 'void' encountered at parameter "
-                                       "position %3, but it can only be the the first and only "
-                                       "parameter")
-                                       .arg(className, functionItem->name()).arg(i);
-            rejectedFunctionSignature = qualifiedFunctionSignatureWithType(className, functionItem);
+                << QString::fromLatin1("skipping function '%1': %2")
+                                       .arg(originalQualifiedSignatureWithReturn, reason);
+            const QString rejectedFunctionSignature = originalQualifiedSignatureWithReturn
+                + QLatin1String(": ") + reason;
             m_rejectedFunctions.insert(rejectedFunctionSignature, AbstractMetaBuilder::UnmatchedArgumentType);
             metaFunction->setInvalid(true);
             return metaFunction;