Moc: parse trailing return type

Fixes: QTBUG-71123
Change-Id: I1c3749f0892fddcc433c9afcb1d6d7c30c97c9d9
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
(cherry picked from commit 12b8283f899ebcf401d974927314b9531334a56e)

5 files changed, 201 insertions, 9 deletions

diff --git a/src/tools/moc/moc.cpp b/src/tools/moc/moc.cpp
index 5f00591fbb..057b1c6324 100644
--- a/src/tools/moc/moc.cpp
+++ b/src/tools/moc/moc.cpp
@@ -219,6 +219,7 @@ Type Moc::parseType()
         case DOUBLE:
         case VOID:
         case BOOL:
+        case AUTO:
             type.name += lexem();
             isVoid |= (lookup(0) == VOID);
             break;
@@ -458,15 +459,6 @@ bool Moc::parseFunction(FunctionDef *def, bool inMacro)
         scopedFunctionName = tempType.isScoped;
     }
 
-    // we don't support references as return types, it's too dangerous
-    if (def->type.referenceType == Type::Reference) {
-        QByteArray rawName = def->type.rawName;
-        def->type = Type("void");
-        def->type.rawName = rawName;
-    }
-
-    def->normalizedType = normalizeType(def->type.name);
-
     if (!test(RPAREN)) {
         parseFunctionArguments(def);
         next(RPAREN);
@@ -489,6 +481,10 @@ bool Moc::parseFunction(FunctionDef *def, bool inMacro)
             next(LPAREN);
             until(RPAREN);
         }
+
+        if (def->type.name == "auto" && test(ARROW))
+            def->type = parseType(); // Parse trailing return-type
+
         if (test(SEMIC))
             ;
         else if ((def->inlineCode = test(LBRACE)))
@@ -506,6 +502,22 @@ bool Moc::parseFunction(FunctionDef *def, bool inMacro)
         warning(msg.constData());
         return false;
     }
+
+    QList<QByteArray> typeNameParts = normalizeType(def->type.name).split(' ');
+    if (typeNameParts.contains("auto")) {
+        // We expected a trailing return type but we haven't seen one
+        error("Function declared with auto as return type but missing trailing return type. "
+              "Return type deduction is not supported.");
+    }
+
+    // we don't support references as return types, it's too dangerous
+    if (def->type.referenceType == Type::Reference) {
+        QByteArray rawName = def->type.rawName;
+        def->type = Type("void");
+        def->type.rawName = rawName;
+    }
+
+    def->normalizedType = normalizeType(def->type.name);
     return true;
 }
 
diff --git a/tests/auto/tools/moc/allmocs_baseline_in.json b/tests/auto/tools/moc/allmocs_baseline_in.json
index 6d17bebb5f..12a4a22a19 100644
--- a/tests/auto/tools/moc/allmocs_baseline_in.json
+++ b/tests/auto/tools/moc/allmocs_baseline_in.json
@@ -1536,6 +1536,79 @@
     {
         "classes": [
             {
+                "className": "CXX11TrailingReturn",
+                "object": true,
+                "qualifiedClassName": "CXX11TrailingReturn",
+                "signals": [
+                    {
+                        "access": "public",
+                        "arguments": [
+                            {
+                                "name": "i",
+                                "type": "int"
+                            }
+                        ],
+                        "name": "trailingSignalReturn",
+                        "returnType": "void"
+                    }
+                ],
+                "slots": [
+                    {
+                        "access": "public",
+                        "name": "fun",
+                        "returnType": "void"
+                    },
+                    {
+                        "access": "public",
+                        "arguments": [
+                            {
+                                "name": "i",
+                                "type": "int"
+                            },
+                            {
+                                "name": "b",
+                                "type": "char"
+                            }
+                        ],
+                        "name": "arguments",
+                        "returnType": "int"
+                    },
+                    {
+                        "access": "public",
+                        "arguments": [
+                            {
+                                "name": "i",
+                                "type": "int"
+                            }
+                        ],
+                        "name": "inlineFunc",
+                        "returnType": "int"
+                    },
+                    {
+                        "access": "public",
+                        "name": "constRefReturn",
+                        "returnType": "void"
+                    },
+                    {
+                        "access": "public",
+                        "name": "constConstRefReturn",
+                        "returnType": "void"
+                    }
+                ],
+                "superClasses": [
+                    {
+                        "access": "public",
+                        "name": "QObject"
+                    }
+                ]
+            }
+        ],
+        "inputFile": "cxx11-trailing-return.h",
+        "outputRevision": 67
+    },
+    {
+        "classes": [
+            {
                 "className": "ForwardDeclaredParamClass",
                 "object": true,
                 "qualifiedClassName": "ForwardDeclaredParamClass",
diff --git a/tests/auto/tools/moc/cxx11-trailing-return.h b/tests/auto/tools/moc/cxx11-trailing-return.h
new file mode 100644
index 0000000000..26178ff68e
--- /dev/null
+++ b/tests/auto/tools/moc/cxx11-trailing-return.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef CXX11_TRAILING_RETURN_H
+#define CXX11_TRAILING_RETURN_H
+#include <QtCore/QObject>
+
+class CXX11TrailingReturn : public QObject
+{
+    Q_OBJECT
+public slots:
+    inline auto fun() -> void;
+    inline auto arguments(int i, char b) -> int;
+    inline auto inlineFunc(int i) -> int
+    {
+        return i + 1;
+    }
+
+    inline auto constRefReturn() -> const CXX11TrailingReturn &
+    {
+        return {};
+    }
+
+    inline auto constConstRefReturn() const -> const CXX11TrailingReturn &
+    {
+        return {};
+    }
+
+signals:
+    auto trailingSignalReturn(int i) -> void;
+};
+
+auto CXX11TrailingReturn::fun() -> void
+{
+    return;
+}
+
+auto CXX11TrailingReturn::arguments(int i, char b) -> int
+{
+    return i + int(b);
+}
+
+#endif // CXX11_TRAILING_RETURN_H
diff --git a/tests/auto/tools/moc/moc.pro b/tests/auto/tools/moc/moc.pro
index cafc7bc184..c324b3a8cd 100644
--- a/tests/auto/tools/moc/moc.pro
+++ b/tests/auto/tools/moc/moc.pro
@@ -19,6 +19,7 @@ HEADERS += using-namespaces.h no-keywords.h task87883.h c-comments.h backslash-n
            task234909.h task240368.h pure-virtual-signals.h cxx11-enums.h \
            cxx11-final-classes.h \
            cxx11-explicit-override-control.h \
+           cxx11-trailing-return.h \
            forward-declared-param.h \
            parse-defines.h \
            function-with-attributes.h \
diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp
index 0f801fe902..c716aead21 100644
--- a/tests/auto/tools/moc/tst_moc.cpp
+++ b/tests/auto/tools/moc/tst_moc.cpp
@@ -62,6 +62,7 @@
 #include "cxx11-enums.h"
 #include "cxx11-final-classes.h"
 #include "cxx11-explicit-override-control.h"
+#include "cxx11-trailing-return.h"
 
 #include "parse-defines.h"
 #include "related-metaobjects-in-namespaces.h"
@@ -687,6 +688,7 @@ private slots:
     void privateClass();
     void cxx11Enums_data();
     void cxx11Enums();
+    void cxx11TrailingReturn();
     void returnRefs();
     void memberProperties_data();
     void memberProperties();
@@ -2200,6 +2202,30 @@ void tst_Moc::warnings_data()
         << QString()
         << QString("standard input:2: Error: Plugin Metadata file \"does.not.exists\" does not exist. Declaration will be ignored");
 
+    QTest::newRow("Auto-declared, missing trailing return")
+        << QByteArray("class X { \n public slots: \n auto fun() { return 1; } };")
+        << QStringList()
+        << 1
+        << QString()
+        << QString("standard input:3: Error: Function declared with auto as return type but missing trailing return type. Return type deduction is not supported.");
+
+    QTest::newRow("Auto-declared, volatile auto as trailing return type")
+        << QByteArray("class X { \n public slots: \n auto fun() -> volatile auto { return 1; } };")
+        << QStringList()
+        << 1
+        << QString()
+        << QString("standard input:3: Error: Function declared with auto as return type but missing trailing return type. Return type deduction is not supported.");
+
+    // We don't currently support the decltype keyword, so it's not the same error as above.
+    // The test is just here to make sure this keeps generating an error until return type deduction
+    // is supported.
+    QTest::newRow("Auto-declared, decltype in trailing return type")
+        << QByteArray("class X { \n public slots: \n auto fun() -> decltype(0+1) { return 1; } };")
+        << QStringList()
+        << 1
+        << QString()
+        << QString("standard input:3: Parse error at \"decltype\"");
+
 #ifdef Q_OS_LINUX  // Limit to Linux because the error message is platform-dependent
     QTest::newRow("Q_PLUGIN_METADATA: unreadable file")
         << QByteArray("class X { \n Q_PLUGIN_METADATA(FILE \".\") \n };")
@@ -2329,6 +2355,18 @@ void tst_Moc::cxx11Enums()
     QCOMPARE(meta->enumerator(idx).isScoped(), isScoped);
 }
 
+void tst_Moc::cxx11TrailingReturn()
+{
+    CXX11TrailingReturn retClass;
+    const QMetaObject *mobj = retClass.metaObject();
+    QVERIFY(mobj->indexOfSlot("fun()") != -1);
+    QVERIFY(mobj->indexOfSlot("arguments(int,char)") != -1);
+    QVERIFY(mobj->indexOfSlot("inlineFunc(int)") != -1);
+    QVERIFY(mobj->indexOfSlot("constRefReturn()") != -1);
+    QVERIFY(mobj->indexOfSlot("constConstRefReturn()") != -1);
+    QVERIFY(mobj->indexOfSignal("trailingSignalReturn(int)") != -1);
+}
+
 void tst_Moc::returnRefs()
 {
     TestClass tst;