diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h index a7aed8d9400..d662ba57899 100644 --- a/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h +++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstorage.h @@ -67,9 +67,12 @@ public: if (!type.sourceId) throw TypeHasInvalidSourceId{}; - updatedTypeIds.push_back(syncType(type)); + updatedTypeIds.push_back(declareType(type)); } + for (auto &&type : types) + syncType(type); + deleteNotUpdatedTypes(updatedTypeIds, sourceIds); transaction.commit(); @@ -85,27 +88,18 @@ public: transaction.commit(); } - TypeId upsertType(Utils::SmallStringView name, - TypeId prototypeId, - Storage::TypeAccessSemantics accessSemantics, - const Storage::ExportedTypes &exportedTypes) + ImportIds fetchImportIds(const Storage::Imports &imports) { - Sqlite::ImmediateTransaction transaction{database}; + ImportIds importIds; - auto typeId = upsertTypeStatement.template value(name, - static_cast(accessSemantics), - &prototypeId); + Sqlite::DeferredTransaction transaction{database}; - for (auto &&exportedType : exportedTypes) { - upsertExportedTypesStatement.write(exportedType.qualifiedTypeName, - exportedType.version.major.version, - exportedType.version.minor.version, - &typeId); - } + for (auto &&import : imports) + importIds.push_back(fetchImportId(import)); transaction.commit(); - return typeId; + return importIds; } PropertyDeclarationId upsertPropertyDeclaration(TypeId typeId, @@ -344,6 +338,7 @@ private: auto remove = [&](const Storage::ImportView &importView) { deleteImportStatement.write(&importView.importId); + deleteTypesForImportId(importView.importId); }; Sqlite::insertUpdateDelete(range, imports, compareKey, insert, update, remove); @@ -408,6 +403,16 @@ private: return selectImportIdByNameStatement.template value(import.name); } + void deleteType(TypeId typeId) + { + deleteExportTypesByTypeIdStatement.write(&typeId); + deleteEnumerationDeclarationByTypeIdStatement.write(&typeId); + deletePropertyDeclarationByTypeIdStatement.write(&typeId); + deleteFunctionDeclarationByTypeIdStatement.write(&typeId); + deleteSignalDeclarationByTypeIdStatement.write(&typeId); + deleteTypeStatement.write(&typeId); + } + void deleteNotUpdatedTypes(const TypeIds &updatedTypeIds, const SourceIds &sourceIds) { auto updatedTypeIdValues = Utils::transform(updatedTypeIds, [](TypeId typeId) { @@ -418,17 +423,24 @@ private: return &sourceId; }); - auto removedTypeIds = selectNotUpdatedTypesInSourcesStatement.template range( - Utils::span(sourceIdValues), Utils::span(updatedTypeIdValues)); + auto callback = [&](long long typeId) { + deleteType(TypeId{typeId}); + return Sqlite::CallbackControl::Continue; + }; - for (TypeId typeId : removedTypeIds) { - resetTypeStatement.write(&typeId); - deleteExportTypesByTypeIdStatement.write(&typeId); - deleteEnumerationDeclarationByTypeIdStatement.write(&typeId); - deletePropertyDeclarationByTypeIdStatement.write(&typeId); - deleteFunctionDeclarationByTypeIdStatement.write(&typeId); - deleteSignalDeclarationByTypeIdStatement.write(&typeId); - } + selectNotUpdatedTypesInSourcesStatement.readCallback(callback, + Utils::span(sourceIdValues), + Utils::span(updatedTypeIdValues)); + } + + void deleteTypesForImportId(ImportId importId) + { + auto callback = [&](long long typeId) { + deleteType(TypeId{typeId}); + return Sqlite::CallbackControl::Continue; + }; + + selectTypeIdsForImportIdStatement.readCallback(callback, &importId); } void upsertExportedType(Utils::SmallStringView qualifiedName, Storage::Version version, TypeId typeId) @@ -654,14 +666,23 @@ private: Sqlite::insertUpdateDelete(range, enumerationDeclarations, compareKey, insert, update, remove); } - TypeId syncType(Storage::Type &type) + TypeId declareType(Storage::Type &type) { + type.typeId = upsertTypeStatement.template value(&type.importId, + type.typeName, + static_cast(type.accessSemantics), + &type.sourceId); + + return type.typeId; + } + + void syncType(Storage::Type &type) + { + auto typeId = type.typeId; + auto prototypeId = fetchTypeIdByName(type.prototype); - auto typeId = upsertTypeStatement.template value(type.typeName, - static_cast(type.accessSemantics), - &prototypeId, - &type.sourceId); + updatePrototypeStatement.write(&typeId, &prototypeId); for (const auto &exportedType : type.exportedTypes) upsertExportedType(exportedType.qualifiedTypeName, exportedType.version, typeId); @@ -670,8 +691,6 @@ private: synchronizeFunctionDeclarations(typeId, type.functionDeclarations); synchronizeSignalDeclarations(typeId, type.signalDeclarations); synchronizeEnumerationDeclarations(typeId, type.enumerationDeclarations); - - return typeId; } TypeId fetchTypeIdByName(Utils::SmallStringView name) @@ -679,12 +698,7 @@ private: if (name.isEmpty()) return TypeId{}; - auto typeId = selectTypeIdByNameStatement.template value(name); - - if (!typeId) - return insertTypeStatement.template value(name); - - return typeId; + return selectTypeIdByNameStatement.template value(name); } SourceContextId readSourceContextId(Utils::SmallStringView sourceContextPath) @@ -794,9 +808,8 @@ private: createImportDependeciesTable(database); createSourceContextsTable(database); createSourcesTable(database); - createTypesTable(database); + createTypesAndePropertyDeclarationsTables(database); createExportedTypesTable(database); - createPropertyDeclarationsTable(database); createEnumerationsTable(database); createFunctionsTable(database); createSignalsTable(database); @@ -840,44 +853,46 @@ private: table.initialize(database); } - void createTypesTable(Database &database) + void createTypesAndePropertyDeclarationsTables(Database &database) { - Sqlite::Table table; - table.setUseIfNotExists(true); - table.setName("types"); - auto &typeIdColumn = table.addColumn("typeId", - Sqlite::ColumnType::Integer, - {Sqlite::PrimaryKey{}}); - auto &nameColumn = table.addColumn("name"); - table.addColumn("accessSemantics"); - table.addColumn("sourceId"); - table.addForeignKeyColumn("prototypeId", - typeIdColumn, - Sqlite::ForeignKeyAction::Restrict, - Sqlite::ForeignKeyAction::Restrict, - Sqlite::Enforment::Deferred); + Sqlite::Table typesTable; + typesTable.setUseIfNotExists(true); + typesTable.setName("types"); + typesTable.addColumn("typeId", Sqlite::ColumnType::Integer, {Sqlite::PrimaryKey{}}); + auto &importIdColumn = typesTable.addColumn("importId"); + auto &typesNameColumn = typesTable.addColumn("name"); + typesTable.addColumn("accessSemantics"); + typesTable.addColumn("sourceId"); + typesTable.addForeignKeyColumn("prototypeId", + typesTable, + Sqlite::ForeignKeyAction::NoAction, + Sqlite::ForeignKeyAction::Restrict, + Sqlite::Enforment::Deferred); - table.addUniqueIndex({nameColumn}); + typesTable.addUniqueIndex({importIdColumn, typesNameColumn}); - table.initialize(database); - } + typesTable.initialize(database); - void createPropertyDeclarationsTable(Database &database) - { - Sqlite::Table table; - table.setUseIfNotExists(true); - table.setName("propertyDeclarations"); - table.addColumn("propertyDeclarationId", - Sqlite::ColumnType::Integer, - {Sqlite::PrimaryKey{}}); - auto &typeIdColumn = table.addColumn("typeId"); - auto &nameColumn = table.addColumn("name"); - table.addColumn("propertyTypeId"); - table.addColumn("propertyTraits"); + { + Sqlite::Table propertyDeclarationTable; + propertyDeclarationTable.setUseIfNotExists(true); + propertyDeclarationTable.setName("propertyDeclarations"); + propertyDeclarationTable.addColumn("propertyDeclarationId", + Sqlite::ColumnType::Integer, + {Sqlite::PrimaryKey{}}); + auto &typeIdColumn = propertyDeclarationTable.addColumn("typeId"); + auto &nameColumn = propertyDeclarationTable.addColumn("name"); + propertyDeclarationTable.addForeignKeyColumn("propertyTypeId", + typesTable, + Sqlite::ForeignKeyAction::NoAction, + Sqlite::ForeignKeyAction::Restrict, + Sqlite::Enforment::Deferred); + propertyDeclarationTable.addColumn("propertyTraits"); - table.addUniqueIndex({typeIdColumn, nameColumn}); + propertyDeclarationTable.addUniqueIndex({typeIdColumn, nameColumn}); - table.initialize(database); + propertyDeclarationTable.initialize(database); + } } void createExportedTypesTable(Database &database) @@ -980,11 +995,13 @@ public: Database &database; Initializer initializer; ReadWriteStatement<1> upsertTypeStatement{ - "INSERT INTO types(name, accessSemantics, prototypeId, sourceId) VALUES(?1, ?2, " - "nullif(?3, -1), nullif(?4, -1)) ON " + "INSERT INTO types(importId, name, accessSemantics, sourceId) VALUES(?1, ?2, " + "?3, nullif(?4, -1)) ON " "CONFLICT DO UPDATE SET prototypeId=excluded.prototypeId, " "accessSemantics=excluded.accessSemantics, sourceId=excluded.sourceId RETURNING typeId", database}; + WriteStatement updatePrototypeStatement{ + "UPDATE types SET prototypeId=nullif(?2, -1) WHERE typeId=?1", database}; mutable ReadStatement<1> selectTypeIdByQualifiedNameStatement{ "SELECT typeId FROM exportedTypes WHERE qualifiedName=?1 AND majorVersion=?2 AND " "minorVersion<=?3 ORDER BY minorVersion DESC LIMIT 1", @@ -1044,20 +1061,19 @@ public: "INSERT INTO sources(sourceContextId, sourceName) VALUES (?,?)", database}; mutable ReadStatement<3> selectAllSourcesStatement{ "SELECT sourceName, sourceContextId, sourceId FROM sources", database}; - ReadWriteStatement<1> insertTypeStatement{"INSERT INTO types(name) VALUES(?) RETURNING typeId", - database}; mutable ReadStatement<1> selectTypeIdByNameStatement{"SELECT typeId FROM types WHERE name=?", database}; - mutable ReadStatement<4> selectTypeByTypeIdStatement{ - "SELECT name, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId), " + mutable ReadStatement<5> selectTypeByTypeIdStatement{ + "SELECT importId, name, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId), " "accessSemantics, ifnull(sourceId, -1) FROM types AS outerTypes WHERE typeId=?", database}; mutable ReadStatement<3> selectExportedTypesByTypeIdStatement{ "SELECT qualifiedName, majorVersion, minorVersion FROM exportedTypes WHERE typeId=?", database}; - mutable ReadStatement<5> selectTypesStatement{ - "SELECT name, typeId, (SELECT name FROM types WHERE typeId=outerTypes.prototypeId)," - "accessSemantics, ifnull(sourceId, -1) FROM types AS outerTypes", + mutable ReadStatement<6> selectTypesStatement{ + "SELECT importId, name, typeId, (SELECT name FROM types WHERE " + "typeId=outerTypes.prototypeId), accessSemantics, ifnull(sourceId, -1) FROM types AS " + "outerTypes", database}; ReadStatement<1> selectNotUpdatedTypesInSourcesStatement{ "SELECT typeId FROM types WHERE (sourceId IN carray(?1) AND typeId NOT IN carray(?2))", @@ -1072,9 +1088,7 @@ public: "DELETE FROM functionDeclarations WHERE typeId=?", database}; WriteStatement deleteSignalDeclarationByTypeIdStatement{ "DELETE FROM signalDeclarations WHERE typeId=?", database}; - WriteStatement resetTypeStatement{ - "UPDATE types SET accessSemantics=NULL, sourceId=NULL, prototypeId=NULL WHERE typeId=?", - database}; + WriteStatement deleteTypeStatement{"DELETE FROM types WHERE typeId=?", database}; mutable ReadStatement<3> selectPropertyDeclarationsByTypeIdStatement{ "SELECT name, (SELECT name FROM types WHERE typeId=propertyDeclarations.propertyTypeId)," "propertyTraits FROM propertyDeclarations WHERE typeId=?", @@ -1179,6 +1193,8 @@ public: "SELECT name, version FROM importDependencies JOIN imports ON " "importDependencies.parentImportId = imports.importId WHERE importDependencies.importId=?", database}; + mutable ReadStatement<1> selectTypeIdsForImportIdStatement{ + "SELECT typeId FROM types WHERE importId=?", database}; }; } // namespace QmlDesigner diff --git a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h index 8486fe97285..d60966bdc8a 100644 --- a/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h +++ b/src/plugins/qmldesigner/designercore/projectstorage/projectstoragetypes.h @@ -371,7 +371,8 @@ class Type { public: explicit Type() = default; - explicit Type(Utils::SmallStringView typeName, + explicit Type(ImportId importId, + Utils::SmallStringView typeName, Utils::SmallStringView prototype, TypeAccessSemantics accessSemantics, SourceId sourceId, @@ -391,9 +392,11 @@ public: , accessSemantics{accessSemantics} , sourceId{sourceId} , typeId{typeId} + , importId{importId} {} - explicit Type(Utils::SmallStringView typeName, + explicit Type(long long importId, + Utils::SmallStringView typeName, Utils::SmallStringView prototype, int accessSemantics, int sourceId) @@ -401,9 +404,12 @@ public: , prototype{prototype} , accessSemantics{static_cast(accessSemantics)} , sourceId{sourceId} + , importId{importId} + {} - explicit Type(Utils::SmallStringView typeName, + explicit Type(long long importId, + Utils::SmallStringView typeName, long long typeId, Utils::SmallStringView prototype, int accessSemantics, @@ -413,6 +419,7 @@ public: , accessSemantics{static_cast(accessSemantics)} , sourceId{sourceId} , typeId{typeId} + , importId{importId} {} public: @@ -427,6 +434,7 @@ public: TypeAccessSemantics accessSemantics = TypeAccessSemantics::Invalid; SourceId sourceId; TypeId typeId; + ImportId importId; bool isCreatable = false; }; diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp index 2ffcd4a6e8a..7f31d417b95 100644 --- a/tests/unit/unittest/gtest-creator-printing.cpp +++ b/tests/unit/unittest/gtest-creator-printing.cpp @@ -1666,9 +1666,9 @@ std::ostream &operator<<(std::ostream &out, const ExportedType &exportedType) std::ostream &operator<<(std::ostream &out, const Type &type) { - return out << "(\"" << type.typeName << "\", \"" << type.prototype << "\", " - << type.accessSemantics << ", source: " << type.sourceId << ", " - << type.exportedTypes << ", " << type.propertyDeclarations << ", " + return out << "(import: " << type.importId << ", \"" << type.typeName << "\", \"" + << type.prototype << "\", " << type.accessSemantics << ", source: " << type.sourceId + << ", " << type.exportedTypes << ", " << type.propertyDeclarations << ", " << type.functionDeclarations << ", " << type.signalDeclarations << ")"; } diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h index 6fe7c8e75d0..d55471393cb 100644 --- a/tests/unit/unittest/gtest-creator-printing.h +++ b/tests/unit/unittest/gtest-creator-printing.h @@ -385,7 +385,7 @@ std::ostream &operator<<(std::ostream &out, const VariantProperty &property); template std::ostream &operator<<(std::ostream &out, const BasicId &id) { - return out << "(" << &id << ")"; + return out << "id=" << &id; } namespace Cache { diff --git a/tests/unit/unittest/projectstorage-test.cpp b/tests/unit/unittest/projectstorage-test.cpp index e7209f597b6..3cfbac731cc 100644 --- a/tests/unit/unittest/projectstorage-test.cpp +++ b/tests/unit/unittest/projectstorage-test.cpp @@ -36,6 +36,7 @@ namespace { +using QmlDesigner::ImportId; using QmlDesigner::PropertyDeclarationId; using QmlDesigner::SourceContextId; using QmlDesigner::SourceId; @@ -68,30 +69,32 @@ MATCHER_P2(IsSourceNameAndSourceContextId, && sourceNameAndSourceContextId.sourceContextId == id; } -MATCHER_P4(IsStorageType, +MATCHER_P5(IsStorageType, + importId, typeName, prototype, accessSemantics, sourceId, std::string(negation ? "isn't " : "is ") - + PrintToString(Storage::Type{typeName, prototype, accessSemantics, sourceId})) + + PrintToString(Storage::Type{importId, typeName, prototype, accessSemantics, sourceId})) { const Storage::Type &type = arg; - return type.typeName == typeName && type.prototype == prototype + return type.importId == importId && type.typeName == typeName && type.prototype == prototype && type.accessSemantics == accessSemantics && type.sourceId == sourceId; } -MATCHER_P3(IsStorageTypeWithInvalidSourceId, +MATCHER_P4(IsStorageTypeWithInvalidSourceId, + importId, typeName, prototype, accessSemantics, std::string(negation ? "isn't " : "is ") - + PrintToString(Storage::Type{typeName, prototype, accessSemantics, SourceId{}})) + + PrintToString(Storage::Type{importId, typeName, prototype, accessSemantics, SourceId{}})) { const Storage::Type &type = arg; - return type.typeName == typeName && type.prototype == prototype + return type.importId == importId && type.typeName == typeName && type.prototype == prototype && type.accessSemantics == accessSemantics && !type.sourceId.isValid(); } @@ -207,57 +210,12 @@ protected: WriteStatement &insertIntoSourcesStatement = storage.insertIntoSourcesStatement; ReadStatement<3> &selectAllSourcesStatement = storage.selectAllSourcesStatement; ReadStatement<1> &selectSourceContextIdFromSourcesBySourceIdStatement = storage.selectSourceContextIdFromSourcesBySourceIdStatement; - ReadWriteStatement<1> &insertTypeStatement = storage.insertTypeStatement; ReadStatement<1> &selectTypeIdByNameStatement = storage.selectTypeIdByNameStatement; - ReadStatement<4> &selectTypeByTypeIdStatement = storage.selectTypeByTypeIdStatement; + ReadStatement<5> &selectTypeByTypeIdStatement = storage.selectTypeByTypeIdStatement; ReadStatement<3> &selectExportedTypesByTypeIdStatement = storage.selectExportedTypesByTypeIdStatement; - ReadStatement<5> &selectTypesStatement = storage.selectTypesStatement; + ReadStatement<6> &selectTypesStatement = storage.selectTypesStatement; }; -TEST_F(ProjectStorage, InsertTypeCalls) -{ - InSequence s; - TypeId prototypeId{3}; - TypeId newTypeId{11}; - - EXPECT_CALL(databaseMock, immediateBegin()); - EXPECT_CALL(upsertTypeStatement, - valueReturnsTypeId(Eq("QObject"), - TypedEq( - static_cast(TypeAccessSemantics::Reference)), - Eq(prototypeId.id))) - .WillOnce(Return(newTypeId)); - EXPECT_CALL(upsertExportedTypesStatement, - write(TypedEq("QML.Object"), - TypedEq(5), - TypedEq(15), - TypedEq(newTypeId.id))); - EXPECT_CALL(upsertExportedTypesStatement, - write(TypedEq("QML.Object"), - TypedEq(5), - TypedEq(12), - TypedEq(newTypeId.id))); - EXPECT_CALL(databaseMock, commit); - - storage.upsertType("QObject", - prototypeId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"QML.Object", Storage::Version{5, 15}}, - Storage::ExportedType{"QML.Object", Storage::Version{5, 12}}}); -} - -TEST_F(ProjectStorage, InsertTypeReturnsInternalPropertyId) -{ - TypeId prototypeId{3}; - TypeId newTypeId{11}; - ON_CALL(upsertTypeStatement, valueReturnsTypeId(Eq("QObject"), _, Eq(prototypeId.id))) - .WillByDefault(Return(newTypeId)); - - auto internalId = storage.upsertType("QObject", prototypeId, TypeAccessSemantics::Reference, {}); - - ASSERT_THAT(internalId, Eq(newTypeId)); -} - TEST_F(ProjectStorage, SelectForFetchingSourceContextIdForKnownPathCalls) { InSequence s; @@ -465,7 +423,7 @@ TEST_F(ProjectStorage, FetchTypeByTypeIdCalls) TEST_F(ProjectStorage, FetchTypesCalls) { InSequence s; - Storage::Type type{{}, {}, {}, SourceId{}, {}, {}, {}, {}, {}, TypeId{55}}; + Storage::Type type{ImportId{}, {}, {}, {}, SourceId{}, {}, {}, {}, {}, {}, TypeId{55}}; Storage::Types types{type}; EXPECT_CALL(databaseMock, deferredBegin()); @@ -505,6 +463,8 @@ protected: auto createTypes() { + setUpImports(); + sourceId1 = sourcePathCache.sourceId(path1); sourceId2 = sourcePathCache.sourceId(path2); sourceId3 = sourcePathCache.sourceId(path3); @@ -512,12 +472,13 @@ protected: return Storage::Types{ Storage::Type{ + importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1, - {Storage::ExportedType{"QtQuick.Item", Storage::Version{5, 15}}, - Storage::ExportedType{"QtQuick.Item", Storage::Version{5, 1}}}, + {Storage::ExportedType{"Item", Storage::Version{5, 15}}, + Storage::ExportedType{"Item", Storage::Version{5, 1}}}, {Storage::PropertyDeclaration{"data", "QObject", Storage::DeclarationTraits::IsList}, Storage::PropertyDeclaration{"children", "QQuickItem", @@ -542,12 +503,13 @@ protected: Storage::EnumerationDeclaration{"Type", {Storage::EnumeratorDeclaration{"Foo"}, Storage::EnumeratorDeclaration{"Poo", 12}}}}}, - Storage::Type{"QObject", + Storage::Type{importId1, + "QObject", {}, TypeAccessSemantics::Reference, sourceId2, - {Storage::ExportedType{"QML.Object", Storage::Version{5, 14}}, - Storage::ExportedType{"Qml.Object", Storage::Version{5, 1}}}}}; + {Storage::ExportedType{"Object", Storage::Version{5, 14}}, + Storage::ExportedType{"Object", Storage::Version{5, 1}}}}}; } auto createImports() @@ -568,6 +530,16 @@ protected: Storage::Import{"Qml", Storage::VersionNumber{2}}}}}; } + void setUpImports() + { + auto imports = createImports(); + storage.synchronizeImports(imports); + auto importIds = storage.fetchImportIds(imports); + importId1 = importIds[0]; + importId2 = importIds[1]; + importId3 = importIds[2]; + } + protected: using ProjectStorage = QmlDesigner::ProjectStorage; Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory}; @@ -587,403 +559,11 @@ protected: SourceId importSourceId1; SourceId importSourceId2; SourceId importSourceId3; + ImportId importId1; + ImportId importId2; + ImportId importId3; }; -TEST_F(ProjectStorageSlowTest, FetchTypeIdByName) -{ - storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi"}}); - auto internalTypeId = storage.upsertType("Er", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Er"}}); - storage.upsertType("San", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.San"}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Er"); - - ASSERT_THAT(id, internalTypeId); -} - -TEST_F(ProjectStorageSlowTest, FetchTypeIdByNameAndVersion) -{ - auto internalTypeId = storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 15}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 1}}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Yi", Storage::Version{5, 1}); - - ASSERT_THAT(id, internalTypeId); -} - -TEST_F(ProjectStorageSlowTest, DontFetchTypeIdByWrongName) -{ - storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 15}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 1}}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Er", Storage::Version{5, 1}); - - ASSERT_FALSE(id.isValid()); -} - -TEST_F(ProjectStorageSlowTest, DontFetchTypeIdByWrongMajorVersion) -{ - storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{3, 15}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 7}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{8, 1}}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Yi", Storage::Version{6, 1}); - - ASSERT_FALSE(id.isValid()); -} - -TEST_F(ProjectStorageSlowTest, DontFetchTypeIdByLowerMinorVersion) -{ - storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 15}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 7}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 1}}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Yi", Storage::Version{5, 0}); - - ASSERT_FALSE(id.isValid()); -} - -TEST_F(ProjectStorageSlowTest, FetchTypeIdByHigherMinorVersion) -{ - storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 7}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 1}}}); - auto internalTypeId = storage.upsertType("Yi2", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 15}}, - Storage::ExportedType{"Qml.Yi", - Storage::Version{5, 12}}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Yi", Storage::Version{5, 13}); - - ASSERT_THAT(id, internalTypeId); -} - -TEST_F(ProjectStorageSlowTest, FetchTypeIdByHigherMiddleVersion) -{ - auto internalTypeId = storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 7}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 1}}}); - storage.upsertType("Yi2", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi", Storage::Version{5, 15}}, - Storage::ExportedType{"Qml.Yi", Storage::Version{5, 12}}}); - - auto id = storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Yi", Storage::Version{5, 11}); - - ASSERT_THAT(id, internalTypeId); -} - -TEST_F(ProjectStorageSlowTest, InsertType) -{ - auto internalTypeId = storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi"}}); - - ASSERT_THAT(storage.fetchTypeIdByQualifiedNameAndVersion("Qml.Yi"), internalTypeId); -} - -TEST_F(ProjectStorageSlowTest, UpsertType) -{ - auto internalTypeId = storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi"}}); - - auto internalTypeId2 = storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi"}}); - - ASSERT_THAT(internalTypeId2, internalTypeId); -} - -TEST_F(ProjectStorageSlowTest, InsertTypeIdAreUnique) -{ - auto internalTypeId = storage.upsertType("Yi", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Yi"}}); - auto internalTypeId2 = storage.upsertType("Er", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Er"}}); - - ASSERT_TRUE(internalTypeId != internalTypeId2); -} - -TEST_F(ProjectStorageSlowTest, IsConvertibleTypeToBase) -{ - auto baseId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto itemId = storage.upsertType("QQuickItem", - objectId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Quick.Item"}}); - - auto isConvertible = storage.fetchIsProtype(itemId, baseId); - - ASSERT_TRUE(isConvertible); -} - -TEST_F(ProjectStorageSlowTest, IsConvertibleTypeToSameType) -{ - auto baseId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto itemId = storage.upsertType("QQuickItem", - objectId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Quick.Item"}}); - - auto isConvertible = storage.fetchIsProtype(itemId, itemId); - - ASSERT_TRUE(isConvertible); -} - -TEST_F(ProjectStorageSlowTest, IsConvertibleTypeToSomeTypeInTheMiddle) -{ - auto baseId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto itemId = storage.upsertType("QQuickItem", - objectId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Quick.Item"}}); - - auto isConvertible = storage.fetchIsProtype(itemId, objectId); - - ASSERT_TRUE(isConvertible); -} - -TEST_F(ProjectStorageSlowTest, IsNotConvertibleToUnrelatedType) -{ - auto unrelatedId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto itemId = storage.upsertType("QQuickItem", - objectId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Quick.Item"}}); - - auto isConvertible = storage.fetchIsProtype(itemId, unrelatedId); - - ASSERT_FALSE(isConvertible); -} - -TEST_F(ProjectStorageSlowTest, IsNotPrototypeOrSameType) -{ - auto baseId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto itemId = storage.upsertType("QQuickItem", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Quick.Item"}}); - - auto isPrototype = storage.fetchIsProtype(itemId, objectId); - - ASSERT_FALSE(isPrototype); -} - -TEST_F(ProjectStorageSlowTest, IsNotConvertibleToDerivedType) -{ - auto baseId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - - auto isConvertible = storage.fetchIsProtype(baseId, objectId); - - ASSERT_FALSE(isConvertible); -} - -TEST_F(ProjectStorageSlowTest, InsertPropertyDeclaration) -{ - auto typeId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto propertyTypeId = storage.upsertType("double", - TypeId{}, - TypeAccessSemantics::Value, - {Storage::ExportedType{"Qml.doube"}}); - - auto propertyDeclarationId = storage.upsertPropertyDeclaration(typeId, "foo", propertyTypeId); - - ASSERT_THAT(storage.fetchPropertyDeclarationByTypeIdAndName(typeId, "foo"), propertyDeclarationId); -} - -TEST_F(ProjectStorageSlowTest, UpsertPropertyDeclaration) -{ - auto typeId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto propertyTypeId = storage.upsertType("double", - TypeId{}, - TypeAccessSemantics::Value, - {Storage::ExportedType{"Qml.doube"}}); - auto propertyDeclarationId = storage.upsertPropertyDeclaration(typeId, "foo", propertyTypeId); - - auto propertyDeclarationId2 = storage.upsertPropertyDeclaration(typeId, "foo", propertyTypeId); - - ASSERT_THAT(propertyDeclarationId2, Eq(propertyDeclarationId)); -} - -TEST_F(ProjectStorageSlowTest, FetchPropertyDeclarationByTypeIdAndNameFromSameType) -{ - auto typeId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto propertyTypeId = storage.upsertType("double", - TypeId{}, - TypeAccessSemantics::Value, - {Storage::ExportedType{"Qml.doube"}}); - auto propertyDeclarationId = storage.upsertPropertyDeclaration(typeId, "foo", propertyTypeId); - - auto id = storage.fetchPropertyDeclarationByTypeIdAndName(typeId, "foo"); - - ASSERT_THAT(id, propertyDeclarationId); -} - -TEST_F(ProjectStorageSlowTest, CannotFetchPropertyDeclarationByTypeIdAndNameForNonExistingProperty) -{ - auto typeId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto propertyTypeId = storage.upsertType("double", - TypeId{}, - TypeAccessSemantics::Value, - {Storage::ExportedType{"Qml.doube"}}); - storage.upsertPropertyDeclaration(typeId, "foo", propertyTypeId); - - auto id = storage.fetchPropertyDeclarationByTypeIdAndName(typeId, "bar"); - - ASSERT_FALSE(id.isValid()); -} - -TEST_F(ProjectStorageSlowTest, FetchPropertyDeclarationByTypeIdAndNameFromDerivedType) -{ - auto baseTypeId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto propertyTypeId = storage.upsertType("double", - TypeId{}, - TypeAccessSemantics::Value, - {Storage::ExportedType{"Qml.doube"}}); - auto derivedTypeId = storage.upsertType("Derived", - baseTypeId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Derived"}}); - auto propertyDeclarationId = storage.upsertPropertyDeclaration(baseTypeId, "foo", propertyTypeId); - - auto id = storage.fetchPropertyDeclarationByTypeIdAndName(derivedTypeId, "foo"); - - ASSERT_THAT(id, propertyDeclarationId); -} - -TEST_F(ProjectStorageSlowTest, FetchPropertyDeclarationByTypeIdAndNameFromBaseType) -{ - auto baseTypeId = storage.upsertType("QObject", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto propertyTypeId = storage.upsertType("double", - TypeId{}, - TypeAccessSemantics::Value, - {Storage::ExportedType{"Qml.doube"}}); - auto derivedTypeId = storage.upsertType("Derived", - baseTypeId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Derived"}}); - storage.upsertPropertyDeclaration(derivedTypeId, "foo", propertyTypeId); - - auto id = storage.fetchPropertyDeclarationByTypeIdAndName(baseTypeId, "foo"); - - ASSERT_FALSE(id.isValid()); -} - -TEST_F(ProjectStorageSlowTest, DISABLED_FetchPrototypes) -{ - auto baseId = storage.upsertType("Base", - TypeId{}, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Base"}}); - auto objectId = storage.upsertType("QObject", - baseId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Qml.Object"}}); - auto itemId = storage.upsertType("QQuickItem", - objectId, - TypeAccessSemantics::Reference, - {Storage::ExportedType{"Quick.Item"}}); - - auto prototypeIds = storage.fetchPrototypes(itemId); - - ASSERT_THAT(prototypeIds, ElementsAre(itemId, objectId, baseId)); -} - TEST_F(ProjectStorageSlowTest, FetchSourceContextIdReturnsAlwaysTheSameIdForTheSamePath) { auto sourceContextId = storage.fetchSourceContextId("/path/to"); @@ -1191,14 +771,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsNewTypes) ASSERT_THAT( storage.fetchTypes(), UnorderedElementsAre( - AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Reference, sourceId2), + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Qml.Object", Storage::Version{5, 1}), - IsExportedType("QML.Object", Storage::Version{5, 14})))), - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Item", Storage::Version{5, 1}), - IsExportedType("QtQuick.Item", Storage::Version{5, 15})))))); + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15})))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsNewTypesReverseOrder) @@ -1211,14 +791,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsNewTypesReverseOrder) ASSERT_THAT( storage.fetchTypes(), UnorderedElementsAre( - AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Reference, sourceId2), + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Qml.Object", Storage::Version{5, 1}), - IsExportedType("QML.Object", Storage::Version{5, 14})))), - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Item", Storage::Version{5, 1}), - IsExportedType("QtQuick.Item", Storage::Version{5, 15})))))); + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15})))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesTypeAccessSemantics) @@ -1233,14 +813,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesTypeAccessSemantics) ASSERT_THAT( storage.fetchTypes(), UnorderedElementsAre( - AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Value, sourceId2), + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Value, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Qml.Object", Storage::Version{5, 1}), - IsExportedType("QML.Object", Storage::Version{5, 14})))), - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Value, sourceId1), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Value, sourceId1), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Item", Storage::Version{5, 1}), - IsExportedType("QtQuick.Item", Storage::Version{5, 15})))))); + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15})))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesSources) @@ -1255,40 +835,40 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesSources) ASSERT_THAT( storage.fetchTypes(), UnorderedElementsAre( - AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Reference, sourceId4), + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId4), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Qml.Object", Storage::Version{5, 1}), - IsExportedType("QML.Object", Storage::Version{5, 14})))), - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId3), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId3), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Item", Storage::Version{5, 1}), - IsExportedType("QtQuick.Item", Storage::Version{5, 15})))))); + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15})))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesOverwritesTypes) { Storage::Types types{createTypes()}; storage.synchronizeTypes(types, {sourceId1, sourceId2}); - types[0].exportedTypes.push_back(Storage::ExportedType{"QtQuick.Item", Storage::Version{5, 19}}); - types[0].exportedTypes.push_back(Storage::ExportedType{"QtQuick.Item", Storage::Version{6, 1}}); - types[1].exportedTypes.push_back(Storage::ExportedType{"Qml.Object", Storage::Version{6, 1}}); + types[0].exportedTypes.push_back(Storage::ExportedType{"Item", Storage::Version{5, 19}}); + types[0].exportedTypes.push_back(Storage::ExportedType{"Item", Storage::Version{6, 1}}); + types[1].exportedTypes.push_back(Storage::ExportedType{"Object", Storage::Version{6, 1}}); storage.synchronizeTypes(types, {sourceId3, sourceId4}); ASSERT_THAT( storage.fetchTypes(), UnorderedElementsAre( - AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Reference, sourceId2), + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Qml.Object", Storage::Version{5, 1}), - IsExportedType("QML.Object", Storage::Version{5, 14}), - IsExportedType("Qml.Object", Storage::Version{6, 1})))), - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14}), + IsExportedType("Object", Storage::Version{6, 1})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Item", Storage::Version{5, 1}), - IsExportedType("QtQuick.Item", Storage::Version{5, 15}), - IsExportedType("QtQuick.Item", Storage::Version{5, 19}), - IsExportedType("QtQuick.Item", Storage::Version{6, 1})))))); + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15}), + IsExportedType("Item", Storage::Version{5, 19}), + IsExportedType("Item", Storage::Version{6, 1})))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesInsertTypeIntoPrototypeChain) @@ -1296,97 +876,102 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesInsertTypeIntoPrototypeChain) Storage::Types types{createTypes()}; storage.synchronizeTypes(types, {sourceId1, sourceId2}); types[0].prototype = "QQuickObject"; - types.push_back(Storage::Type{"QQuickObject", + types.push_back(Storage::Type{importId2, + "QQuickObject", "QObject", TypeAccessSemantics::Reference, sourceId1, - {Storage::ExportedType{"QtQuick.Object", Storage::Version{5, 15}}}}); + {Storage::ExportedType{"Object", Storage::Version{5, 15}}}}); storage.synchronizeTypes(types, {sourceId1, sourceId2}); ASSERT_THAT( storage.fetchTypes(), UnorderedElementsAre( - AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Reference, sourceId2), + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("Qml.Object", Storage::Version{5, 1}), - IsExportedType("QML.Object", Storage::Version{5, 14})))), - AllOf(IsStorageType("QQuickObject", "QObject", TypeAccessSemantics::Reference, sourceId1), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))), + AllOf(IsStorageType(importId2, "QQuickObject", "QObject", TypeAccessSemantics::Reference, sourceId1), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Object", Storage::Version{5, 15})))), - AllOf(IsStorageType("QQuickItem", "QQuickObject", TypeAccessSemantics::Reference, sourceId1), + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 15})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QQuickObject", TypeAccessSemantics::Reference, sourceId1), Field(&Storage::Type::exportedTypes, - UnorderedElementsAre(IsExportedType("QtQuick.Item", Storage::Version{5, 1}), - IsExportedType("QtQuick.Item", Storage::Version{5, 15})))))); + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15})))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesDontThrowsForMissingPrototype) { sourceId1 = sourcePathCache.sourceId(path1); - Storage::Types types{ - Storage::Type{"QQuickItem", - "QObject", - TypeAccessSemantics::Reference, - sourceId1, - {Storage::ExportedType{"QtQuick.Item", Storage::Version{5, 15}}}}}; + Storage::Types types{Storage::Type{importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1, + {Storage::ExportedType{"Item", Storage::Version{5, 15}}}}}; ASSERT_NO_THROW(storage.synchronizeTypes(types, {sourceId1})); } TEST_F(ProjectStorageSlowTest, TypeWithInvalidSourceIdThrows) { - Storage::Types types{ - Storage::Type{"QQuickItem", - "", - TypeAccessSemantics::Reference, - SourceId{}, - {Storage::ExportedType{"QtQuick.Item", Storage::Version{5, 15}}}}}; + Storage::Types types{Storage::Type{importId2, + "QQuickItem", + "", + TypeAccessSemantics::Reference, + SourceId{}, + {Storage::ExportedType{"Item", Storage::Version{5, 15}}}}}; ASSERT_THROW(storage.synchronizeTypes(types, {}), QmlDesigner::TypeHasInvalidSourceId); } -TEST_F(ProjectStorageSlowTest, ResetsTypeIfTypeIsRemoved) +TEST_F(ProjectStorageSlowTest, DeleteTypeIfSourceIdIsSynchronized) { Storage::Types types{createTypes()}; - types[1].enumerationDeclarations = types[0].enumerationDeclarations; - types[1].propertyDeclarations = types[0].propertyDeclarations; - types[1].functionDeclarations = types[0].functionDeclarations; - types[1].signalDeclarations = types[0].signalDeclarations; storage.synchronizeTypes(types, {sourceId1, sourceId2}); - types.pop_back(); + types.erase(types.begin()); storage.synchronizeTypes(types, {sourceId1, sourceId2}); - ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageTypeWithInvalidSourceId("QObject", "", TypeAccessSemantics::Invalid), - Field(&Storage::Type::exportedTypes, IsEmpty()), - Field(&Storage::Type::enumerationDeclarations, IsEmpty()), - Field(&Storage::Type::propertyDeclarations, IsEmpty()), - Field(&Storage::Type::functionDeclarations, IsEmpty()), - Field(&Storage::Type::signalDeclarations, IsEmpty())))); + ASSERT_THAT( + storage.fetchTypes(), + UnorderedElementsAre( + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), + Field(&Storage::Type::exportedTypes, + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))))); } -TEST_F(ProjectStorageSlowTest, DontResetsTypeIfSourceIdIsNotSynchronized) +TEST_F(ProjectStorageSlowTest, DontDeleteTypeIfSourceIdIsNotSynchronized) { Storage::Types types{createTypes()}; - types[1].enumerationDeclarations = types[0].enumerationDeclarations; - types[1].propertyDeclarations = types[0].propertyDeclarations; - types[1].functionDeclarations = types[0].functionDeclarations; - types[1].signalDeclarations = types[0].signalDeclarations; storage.synchronizeTypes(types, {sourceId1, sourceId2}); types.pop_back(); storage.synchronizeTypes(types, {sourceId1}); - ASSERT_THAT(storage.fetchTypes(), - Contains(AllOf(IsStorageType("QObject", "", TypeAccessSemantics::Reference, sourceId2), - Field(&Storage::Type::exportedTypes, Not(IsEmpty())), - Field(&Storage::Type::exportedTypes, Not(IsEmpty())), - Field(&Storage::Type::enumerationDeclarations, Not(IsEmpty())), - Field(&Storage::Type::propertyDeclarations, Not(IsEmpty())), - Field(&Storage::Type::functionDeclarations, Not(IsEmpty())), - Field(&Storage::Type::signalDeclarations, Not(IsEmpty()))))); + ASSERT_THAT( + storage.fetchTypes(), + UnorderedElementsAre( + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), + Field(&Storage::Type::exportedTypes, + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))), + AllOf(IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + Field(&Storage::Type::exportedTypes, + UnorderedElementsAre(IsExportedType("Item", Storage::Version{5, 1}), + IsExportedType("Item", Storage::Version{5, 15})))))); +} + +TEST_F(ProjectStorageSlowTest, BreakingPrototypeChainByDeletingBaseComponentThrows) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + types.pop_back(); + + ASSERT_THROW(storage.synchronizeTypes(types, {sourceId1, sourceId2}), + Sqlite::ConstraintPreventsModification); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddPropertyDeclarations) @@ -1397,15 +982,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddPropertyDeclarations) ASSERT_THAT( storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::propertyDeclarations, - UnorderedElementsAre( - IsPropertyDeclaration("data", "QObject", Storage::DeclarationTraits::IsList), - IsPropertyDeclaration("children", - "QQuickItem", - Storage::DeclarationTraits::IsList - | Storage::DeclarationTraits::IsReadOnly)))))); + Contains(AllOf( + IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + Field(&Storage::Type::propertyDeclarations, + UnorderedElementsAre( + IsPropertyDeclaration("data", "QObject", Storage::DeclarationTraits::IsList), + IsPropertyDeclaration("children", + "QQuickItem", + Storage::DeclarationTraits::IsList + | Storage::DeclarationTraits::IsReadOnly)))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesPropertyDeclarationType) @@ -1418,15 +1003,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesPropertyDeclarationType) ASSERT_THAT( storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::propertyDeclarations, - UnorderedElementsAre( - IsPropertyDeclaration("data", "QQuickItem", Storage::DeclarationTraits::IsList), - IsPropertyDeclaration("children", - "QQuickItem", - Storage::DeclarationTraits::IsList - | Storage::DeclarationTraits::IsReadOnly)))))); + Contains(AllOf( + IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + Field(&Storage::Type::propertyDeclarations, + UnorderedElementsAre( + IsPropertyDeclaration("data", "QQuickItem", Storage::DeclarationTraits::IsList), + IsPropertyDeclaration("children", + "QQuickItem", + Storage::DeclarationTraits::IsList + | Storage::DeclarationTraits::IsReadOnly)))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesDeclarationTraits) @@ -1439,15 +1024,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesDeclarationTraits) ASSERT_THAT( storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::propertyDeclarations, - UnorderedElementsAre( - IsPropertyDeclaration("data", "QObject", Storage::DeclarationTraits::IsPointer), - IsPropertyDeclaration("children", - "QQuickItem", - Storage::DeclarationTraits::IsList - | Storage::DeclarationTraits::IsReadOnly)))))); + Contains(AllOf( + IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + Field(&Storage::Type::propertyDeclarations, + UnorderedElementsAre( + IsPropertyDeclaration("data", "QObject", Storage::DeclarationTraits::IsPointer), + IsPropertyDeclaration("children", + "QQuickItem", + Storage::DeclarationTraits::IsList + | Storage::DeclarationTraits::IsReadOnly)))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesDeclarationTraitsAndType) @@ -1461,15 +1046,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesDeclarationTraitsAndType) ASSERT_THAT( storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::propertyDeclarations, - UnorderedElementsAre( - IsPropertyDeclaration("data", "QQuickItem", Storage::DeclarationTraits::IsPointer), - IsPropertyDeclaration("children", - "QQuickItem", - Storage::DeclarationTraits::IsList - | Storage::DeclarationTraits::IsReadOnly)))))); + Contains(AllOf( + IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + Field(&Storage::Type::propertyDeclarations, + UnorderedElementsAre( + IsPropertyDeclaration("data", "QQuickItem", Storage::DeclarationTraits::IsPointer), + IsPropertyDeclaration("children", + "QQuickItem", + Storage::DeclarationTraits::IsList + | Storage::DeclarationTraits::IsReadOnly)))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesAPropertyDeclaration) @@ -1481,11 +1066,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesAPropertyDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::propertyDeclarations, - UnorderedElementsAre(IsPropertyDeclaration( - "data", "QObject", Storage::DeclarationTraits::IsList)))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::propertyDeclarations, + UnorderedElementsAre(IsPropertyDeclaration( + "data", "QObject", Storage::DeclarationTraits::IsList)))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsAPropertyDeclaration) @@ -1500,7 +1088,7 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddsAPropertyDeclaration) ASSERT_THAT( storage.fetchTypes(), Contains(AllOf( - IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), Field(&Storage::Type::propertyDeclarations, UnorderedElementsAre( IsPropertyDeclaration("object", "QObject", Storage::DeclarationTraits::IsPointer), @@ -1521,15 +1109,36 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesRenameAPropertyDeclaration) ASSERT_THAT( storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::propertyDeclarations, - UnorderedElementsAre( - IsPropertyDeclaration("data", "QObject", Storage::DeclarationTraits::IsList), - IsPropertyDeclaration("objects", - "QQuickItem", - Storage::DeclarationTraits::IsList - | Storage::DeclarationTraits::IsReadOnly)))))); + Contains(AllOf( + IsStorageType(importId2, "QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), + Field(&Storage::Type::propertyDeclarations, + UnorderedElementsAre( + IsPropertyDeclaration("data", "QObject", Storage::DeclarationTraits::IsList), + IsPropertyDeclaration("objects", + "QQuickItem", + Storage::DeclarationTraits::IsList + | Storage::DeclarationTraits::IsReadOnly)))))); +} + +TEST_F(ProjectStorageSlowTest, UsingNonExistingPropertyTypeThrows) +{ + Storage::Types types{createTypes()}; + types[0].propertyDeclarations[0].typeName = "QObject2"; + types.pop_back(); + + ASSERT_THROW(storage.synchronizeTypes(types, {sourceId1, sourceId2}), + Sqlite::ConstraintPreventsModification); +} + +TEST_F(ProjectStorageSlowTest, BreakingPropertyDeclarationTypeDependencyByDeletingTypeThrows) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + types[0].prototype.clear(); + types.pop_back(); + + ASSERT_THROW(storage.synchronizeTypes(types, {sourceId1, sourceId2}), + Sqlite::ConstraintPreventsModification); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddFunctionDeclarations) @@ -1539,11 +1148,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddFunctionDeclarations) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationReturnType) @@ -1555,11 +1167,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationReturnT storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationName) @@ -1571,11 +1186,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationName) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationPopParameters) @@ -1587,11 +1205,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationPopPara storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationAppendParameters) @@ -1603,11 +1224,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationAppendP storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationChangeParameterName) @@ -1619,11 +1243,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationChangeP storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationChangeParameterTypeName) @@ -1635,11 +1262,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationChangeP storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationChangeParameterTraits) @@ -1651,11 +1281,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesFunctionDeclarationChangeP storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesFunctionDeclaration) @@ -1667,10 +1300,13 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesFunctionDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddFunctionDeclaration) @@ -1683,12 +1319,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddFunctionDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::functionDeclarations, - UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), - Eq(types[0].functionDeclarations[1]), - Eq(types[0].functionDeclarations[2])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::functionDeclarations, + UnorderedElementsAre(Eq(types[0].functionDeclarations[0]), + Eq(types[0].functionDeclarations[1]), + Eq(types[0].functionDeclarations[2])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddSignalDeclarations) @@ -1698,11 +1337,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddSignalDeclarations) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationName) @@ -1714,11 +1356,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationName) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationPopParameters) @@ -1730,11 +1375,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationPopParame storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationAppendParameters) @@ -1746,11 +1394,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationAppendPar storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationChangeParameterName) @@ -1762,11 +1413,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationChangePar storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationChangeParameterTypeName) @@ -1778,11 +1432,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationChangePar storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationChangeParameterTraits) @@ -1794,11 +1451,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesSignalDeclarationChangePar storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesSignalDeclaration) @@ -1810,10 +1470,13 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesSignalDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddSignalDeclaration) @@ -1826,12 +1489,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddSignalDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::signalDeclarations, - UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), - Eq(types[0].signalDeclarations[1]), - Eq(types[0].signalDeclarations[2])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::signalDeclarations, + UnorderedElementsAre(Eq(types[0].signalDeclarations[0]), + Eq(types[0].signalDeclarations[1]), + Eq(types[0].signalDeclarations[2])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddEnumerationDeclarations) @@ -1841,11 +1507,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddEnumerationDeclarations) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesEnumerationDeclarationName) @@ -1857,11 +1526,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesEnumerationDeclarationName storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesEnumerationDeclarationPopEnumeratorDeclaration) @@ -1873,11 +1545,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesEnumerationDeclarationPopE storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesEnumerationDeclarationAppendEnumeratorDeclaration) @@ -1890,11 +1565,14 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesChangesEnumerationDeclarationAppe storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, @@ -1907,11 +1585,14 @@ TEST_F(ProjectStorageSlowTest, storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, @@ -1924,11 +1605,14 @@ TEST_F(ProjectStorageSlowTest, storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, @@ -1942,11 +1626,14 @@ TEST_F(ProjectStorageSlowTest, storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, @@ -1959,11 +1646,14 @@ TEST_F(ProjectStorageSlowTest, storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesEnumerationDeclaration) @@ -1975,10 +1665,13 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesRemovesEnumerationDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddEnumerationDeclaration) @@ -1991,12 +1684,15 @@ TEST_F(ProjectStorageSlowTest, SynchronizeTypesAddEnumerationDeclaration) storage.synchronizeTypes(types, {}); ASSERT_THAT(storage.fetchTypes(), - Contains( - AllOf(IsStorageType("QQuickItem", "QObject", TypeAccessSemantics::Reference, sourceId1), - Field(&Storage::Type::enumerationDeclarations, - UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), - Eq(types[0].enumerationDeclarations[1]), - Eq(types[0].enumerationDeclarations[2])))))); + Contains(AllOf(IsStorageType(importId2, + "QQuickItem", + "QObject", + TypeAccessSemantics::Reference, + sourceId1), + Field(&Storage::Type::enumerationDeclarations, + UnorderedElementsAre(Eq(types[0].enumerationDeclarations[0]), + Eq(types[0].enumerationDeclarations[1]), + Eq(types[0].enumerationDeclarations[2])))))); } TEST_F(ProjectStorageSlowTest, SynchronizeImportsAddImports) @@ -2268,4 +1964,22 @@ TEST_F(ProjectStorageSlowTest, SynchronizeImportsDependencyRemoveDuplicateDepend IsBasicImport("QtQuick", Storage::VersionNumber{})))))); } +TEST_F(ProjectStorageSlowTest, RemovingImportRemovesDependentTypesToo) +{ + Storage::Types types{createTypes()}; + storage.synchronizeTypes(types, {sourceId1, sourceId2}); + Storage::Imports imports{createImports()}; + imports.pop_back(); + imports.pop_back(); + storage.synchronizeImports(imports); + + ASSERT_THAT( + storage.fetchTypes(), + UnorderedElementsAre( + AllOf(IsStorageType(importId1, "QObject", "", TypeAccessSemantics::Reference, sourceId2), + Field(&Storage::Type::exportedTypes, + UnorderedElementsAre(IsExportedType("Object", Storage::Version{5, 1}), + IsExportedType("Object", Storage::Version{5, 14})))))); +} + } // namespace