QmlDesigner: Handle signal overloads

Signals can be overloaded and we should handle that case.

Task-number: QDS-6669
Change-Id: I70272d90aff11c7705de70f1ed55676813c8b5ff
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Henning Gründl <henning.gruendl@qt.io>

src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h

@@ -1491,7 +1491,16 @@ private:
     void synchronizeSignalDeclarations(TypeId typeId, Storage::SignalDeclarations &signalDeclarations)
     {
         std::sort(signalDeclarations.begin(), signalDeclarations.end(), [](auto &&first, auto &&second) {
-            return Sqlite::compare(first.name, second.name) < 0;
+            auto compare = Sqlite::compare(first.name, second.name);
+
+            if (compare == 0) {
+                Utils::PathString firstSignature{createJson(first.parameters)};
+                Utils::PathString secondSignature{createJson(second.parameters)};
+
+                return Sqlite::compare(firstSignature, secondSignature) < 0;
+            }
+
+            return compare < 0;
         });
 
         auto range = selectSignalDeclarationsForTypeIdStatement
@@ -1499,7 +1508,13 @@ private:
 
         auto compareKey = [](const Storage::SignalDeclarationView &view,
                              const Storage::SignalDeclaration &value) {
-            return Sqlite::compare(view.name, value.name);
+            auto nameKey = Sqlite::compare(view.name, value.name);
+            if (nameKey != 0)
+                return nameKey;
+
+            Utils::PathString valueSignature{createJson(value.parameters)};
+
+            return Sqlite::compare(view.signature, valueSignature);
         };
 
         auto insert = [&](const Storage::SignalDeclaration &value) {
@@ -1510,14 +1525,7 @@ private:
 
         auto update = [&](const Storage::SignalDeclarationView &view,
                           const Storage::SignalDeclaration &value) {
-            Utils::PathString signature{createJson(value.parameters)};
-
-            if (signature == view.signature)
             return Sqlite::UpdateChange::No;
-
-            updateSignalDeclarationStatement.write(&view.id, signature);
-
-            return Sqlite::UpdateChange::Update;
         };
 
         auto remove = [&](const Storage::SignalDeclarationView &view) {
@@ -2465,7 +2473,7 @@ public:
         "DELETE FROM functionDeclarations WHERE functionDeclarationId=?", database};
     mutable ReadStatement<3, 1> selectSignalDeclarationsForTypeIdStatement{
         "SELECT name, signature, signalDeclarationId FROM signalDeclarations WHERE typeId=? ORDER "
-        "BY name",
+        "BY name, signature",
         database};
     mutable ReadStatement<2, 1> selectSignalDeclarationsForTypeIdWithoutSignatureStatement{
         "SELECT name, signalDeclarationId FROM signalDeclarations WHERE typeId=? ORDER BY name",

tests/unit/unittest/projectstorage-test.cpp

@@ -248,7 +248,7 @@ protected:
                                                 Storage::PropertyDeclarationTraits::IsPointer},
                   Storage::ParameterDeclaration{"arg3", "string"}}}},
             {Storage::SignalDeclaration{"execute", {Storage::ParameterDeclaration{"arg", ""}}},
-             Storage::SignalDeclaration{"value0s",
+             Storage::SignalDeclaration{"values",
                                         {Storage::ParameterDeclaration{"arg1", "int"},
                                          Storage::ParameterDeclaration{
                                              "arg2", "QObject", Storage::PropertyDeclarationTraits::IsPointer},
@@ -1744,6 +1744,65 @@ TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclaration)
                                                      Eq(package.types[0].signalDeclarations[2]))))));
 }
 
+TEST_F(ProjectStorage, SynchronizeTypesAddSignalDeclarationsWithOverloads)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    package.types[0].signalDeclarations.push_back(Storage::SignalDeclaration{"execute", {}});
+
+    storage.synchronize(package);
+
+    ASSERT_THAT(storage.fetchTypes(),
+                Contains(
+                    AllOf(IsStorageType(sourceId1,
+                                        "QQuickItem",
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
+                          Field(&Storage::Type::signalDeclarations,
+                                UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
+                                                     Eq(package.types[0].signalDeclarations[1]),
+                                                     Eq(package.types[0].signalDeclarations[2]))))));
+}
+
+TEST_F(ProjectStorage, SynchronizeTypesSignalDeclarationsAddingOverload)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    storage.synchronize(package);
+    package.types[0].signalDeclarations.push_back(Storage::SignalDeclaration{"execute", {}});
+
+    storage.synchronize(package);
+
+    ASSERT_THAT(storage.fetchTypes(),
+                Contains(
+                    AllOf(IsStorageType(sourceId1,
+                                        "QQuickItem",
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
+                          Field(&Storage::Type::signalDeclarations,
+                                UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
+                                                     Eq(package.types[0].signalDeclarations[1]),
+                                                     Eq(package.types[0].signalDeclarations[2]))))));
+}
+
+TEST_F(ProjectStorage, SynchronizeTypesSignalDeclarationsRemovingOverload)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    package.types[0].signalDeclarations.push_back(Storage::SignalDeclaration{"execute", {}});
+    storage.synchronize(package);
+    package.types[0].signalDeclarations.pop_back();
+
+    storage.synchronize(package);
+
+    ASSERT_THAT(storage.fetchTypes(),
+                Contains(
+                    AllOf(IsStorageType(sourceId1,
+                                        "QQuickItem",
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeAccessSemantics::Reference),
+                          Field(&Storage::Type::signalDeclarations,
+                                UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
+                                                     Eq(package.types[0].signalDeclarations[1]))))));
+}
+
 TEST_F(ProjectStorage, SynchronizeTypesAddEnumerationDeclarations)
 {
     auto package{createSimpleSynchronizationPackage()};