diff --git a/tests/unit/README.md b/tests/unit/README.md
index 396633f10a2..4134c8609f1 100644
--- a/tests/unit/README.md
+++ b/tests/unit/README.md
@@ -109,8 +109,8 @@ TEST_F(Storage, return_all_entries_with_the_name_which_starts_with_foo)
 
     auto entries = storage.entries("foo*");
 
-    ASSERT_THAT(entries, UnorderedElementsAre(IsEntry("foo", Field(&Entry::values), Contains(5)),
-                                              IsEntry("fooBar", Field(&Entry::values), IsSubset(42, 77))));
+    ASSERT_THAT(entries, UnorderedElementsAre(IsEntry("foo", Field("Entry::values)", &Entry::values, Contains(5)),
+                                              IsEntry("fooBar", Field("Entry::values", &Entry::values, IsSubset(42, 77))));
 }
 ```
 
@@ -120,7 +120,7 @@ You can even make the matcher easier to read.
 template<typename Matcher>
 auto FieldValues(const Matcher &matcher)
 {
-    return Field(&Entry::values, matcher);
+    return Field("Entry::values", &Entry::values, matcher);
 }
 
 TEST_F(Storage, return_all_entries_with_the_name_which_starts_with_foo)
diff --git a/tests/unit/tests/matchers/import-matcher.h b/tests/unit/tests/matchers/import-matcher.h
index 067f16fae55..4fb389fcd82 100644
--- a/tests/unit/tests/matchers/import-matcher.h
+++ b/tests/unit/tests/matchers/import-matcher.h
@@ -16,9 +16,9 @@ auto IsImport(const ModuleIdMatcher &moduleIdMatcher,
               const MajorVersionMatcher &majorVersionMatcher,
               const MinorVersionMatcher &minorVersionMatcher)
 {
-    return AllOf(Field(&QmlDesigner::Storage::Import::moduleId, moduleIdMatcher),
-                 Field(&QmlDesigner::Storage::Import::sourceId, sourceIdMatcher),
-                 Field(&QmlDesigner::Storage::Import::version,
+    return AllOf(Field("QmlDesigner::Storage::Import::moduleId", &QmlDesigner::Storage::Import::moduleId, moduleIdMatcher),
+                 Field("QmlDesigner::Storage::Import::sourceId", &QmlDesigner::Storage::Import::sourceId, sourceIdMatcher),
+                 Field("QmlDesigner::Storage::Import::version", &QmlDesigner::Storage::Import::version,
                        IsVersion(majorVersionMatcher, minorVersionMatcher)));
 }
 
@@ -27,7 +27,7 @@ auto IsImport(const ModuleIdMatcher &moduleIdMatcher,
               const SourceIdMatcher &sourceIdMatcher,
               const VersionMatcher &versionMatcher)
 {
-    return AllOf(Field(&QmlDesigner::Storage::Import::moduleId, moduleIdMatcher),
-                 Field(&QmlDesigner::Storage::Import::sourceId, sourceIdMatcher),
-                 Field(&QmlDesigner::Storage::Import::version, versionMatcher));
+    return AllOf(Field("QmlDesigner::Storage::Import::moduleId", &QmlDesigner::Storage::Import::moduleId, moduleIdMatcher),
+                 Field("QmlDesigner::Storage::Import::sourceId", &QmlDesigner::Storage::Import::sourceId, sourceIdMatcher),
+                 Field("QmlDesigner::Storage::Import::version", &QmlDesigner::Storage::Import::version, versionMatcher));
 }
diff --git a/tests/unit/tests/matchers/info_exportedtypenames-matcher.h b/tests/unit/tests/matchers/info_exportedtypenames-matcher.h
index dbe86d8d31d..8ef86e53dec 100644
--- a/tests/unit/tests/matchers/info_exportedtypenames-matcher.h
+++ b/tests/unit/tests/matchers/info_exportedtypenames-matcher.h
@@ -16,9 +16,9 @@ auto IsInfoExportTypeNames(const ModuleIdMatcher &moduleIdMatcher,
                            const MajorVersionMatcher &majorVersionMatcher,
                            const MinorVersionMatcher &minorVersionMatcher)
 {
-    return AllOf(Field(&QmlDesigner::Storage::Info::ExportedTypeName::moduleId, moduleIdMatcher),
-                 Field(&QmlDesigner::Storage::Info::ExportedTypeName::name, nameMatcher),
-                 Field(&QmlDesigner::Storage::Info::ExportedTypeName::version,
+    return AllOf(Field("QmlDesigner::Storage::Info::ExportedTypeName::moduleId", &QmlDesigner::Storage::Info::ExportedTypeName::moduleId, moduleIdMatcher),
+                 Field("QmlDesigner::Storage::Info::ExportedTypeName::name", &QmlDesigner::Storage::Info::ExportedTypeName::name, nameMatcher),
+                 Field("QmlDesigner::Storage::Info::ExportedTypeName::version", &QmlDesigner::Storage::Info::ExportedTypeName::version,
                        IsVersion(majorVersionMatcher, minorVersionMatcher)));
 }
 
@@ -27,7 +27,7 @@ auto IsInfoExportTypeNames(const ModuleIdMatcher &moduleIdMatcher,
                            const NameMatcher &nameMatcher,
                            const VersionMatcher &versionMatcher)
 {
-    return AllOf(Field(&QmlDesigner::Storage::Info::ExportedTypeName::moduleId, moduleIdMatcher),
-                 Field(&QmlDesigner::Storage::Info::ExportedTypeName::name, nameMatcher),
-                 Field(&QmlDesigner::Storage::Info::ExportedTypeName::version, versionMatcher));
+    return AllOf(Field("QmlDesigner::Storage::Info::ExportedTypeName::moduleId", &QmlDesigner::Storage::Info::ExportedTypeName::moduleId, moduleIdMatcher),
+                 Field("QmlDesigner::Storage::Info::ExportedTypeName::name", &QmlDesigner::Storage::Info::ExportedTypeName::name, nameMatcher),
+                 Field("QmlDesigner::Storage::Info::ExportedTypeName::version", &QmlDesigner::Storage::Info::ExportedTypeName::version, versionMatcher));
 }
diff --git a/tests/unit/tests/matchers/qvariant-matcher.h b/tests/unit/tests/matchers/qvariant-matcher.h
index 52693ff2dca..2d900092ee8 100644
--- a/tests/unit/tests/matchers/qvariant-matcher.h
+++ b/tests/unit/tests/matchers/qvariant-matcher.h
@@ -34,11 +34,12 @@ testing::Matcher<QVariant> IsQVariantType()
 template<typename Type, typename Matcher>
 auto IsQVariant(const Matcher &matcher)
 {
-    return AllOf(IsQVariantType<Type>(), Property(&QVariant::value<Type>, matcher));
+    return AllOf(IsQVariantType<Type>(),
+                 Property("QVariant::value<Type>", &QVariant::value<Type>, matcher));
 }
 
 template<typename Matcher>
 auto QVariantIsValid(const Matcher &matcher)
 {
-    return Property(&QVariant::isValid, matcher);
+    return Property("QVariant::isValid", &QVariant::isValid, matcher);
 }
diff --git a/tests/unit/tests/matchers/version-matcher.h b/tests/unit/tests/matchers/version-matcher.h
index d4c4b1c55f8..302722f6f9a 100644
--- a/tests/unit/tests/matchers/version-matcher.h
+++ b/tests/unit/tests/matchers/version-matcher.h
@@ -11,19 +11,19 @@
 template<typename Matcher>
 auto IsVersionNumber(const Matcher &matcher)
 {
-    return Field(&QmlDesigner::Storage::VersionNumber::value, matcher);
+    return Field("QmlDesigner::Storage::VersionNumber::value", &QmlDesigner::Storage::VersionNumber::value, matcher);
 }
 
 template<typename Matcher>
 auto IsMinorVersion(const Matcher &matcher)
 {
-    return Field(&QmlDesigner::Storage::Version::minor, matcher);
+    return Field("QmlDesigner::Storage::Version::minor", &QmlDesigner::Storage::Version::minor, matcher);
 }
 
 template<typename Matcher>
 auto IsMajorVersion(const Matcher &matcher)
 {
-    return Field(&QmlDesigner::Storage::Version::major, matcher);
+    return Field("QmlDesigner::Storage::Version::major", &QmlDesigner::Storage::Version::major, matcher);
 }
 
 template<typename MajorMatcher, typename MinorMatcher>
diff --git a/tests/unit/tests/unittests/componentcore/propertycomponentgenerator-test.cpp b/tests/unit/tests/unittests/componentcore/propertycomponentgenerator-test.cpp
index 72788bbd83e..4b398420082 100644
--- a/tests/unit/tests/unittests/componentcore/propertycomponentgenerator-test.cpp
+++ b/tests/unit/tests/unittests/componentcore/propertycomponentgenerator-test.cpp
@@ -36,13 +36,15 @@ using ComplexProperty = QmlDesigner::PropertyComponentGenerator::ComplexProperty
 template<typename Matcher>
 auto IsBasicProperty(const Matcher &matcher)
 {
-    return VariantWith<BasicProperty>(Field(&BasicProperty::component, matcher));
+    return VariantWith<BasicProperty>(
+        Field("BasicProperty::component", &BasicProperty::component, matcher));
 }
 
 template<typename Matcher>
 auto IsComplexProperty(const Matcher &matcher)
 {
-    return VariantWith<ComplexProperty>(Field(&ComplexProperty::component, matcher));
+    return VariantWith<ComplexProperty>(
+        Field("ComplexProperty::component", &ComplexProperty::component, matcher));
 }
 
 constexpr Utils::SmallStringView sourcesPath = UNITTEST_DIR
diff --git a/tests/unit/tests/unittests/designsystem/dsthememgr-test.cpp b/tests/unit/tests/unittests/designsystem/dsthememgr-test.cpp
index 393af1c76d3..bd10e631c64 100644
--- a/tests/unit/tests/unittests/designsystem/dsthememgr-test.cpp
+++ b/tests/unit/tests/unittests/designsystem/dsthememgr-test.cpp
@@ -97,7 +97,7 @@ TEST(DesignSystemManagerTest, remove_theme)
     mgr.removeTheme(*themeId);
 
     // assert
-    ASSERT_THAT(mgr, Property(&DSThemeManager::themeCount, 0));
+    ASSERT_THAT(mgr, Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 0));
 }
 
 TEST(DesignSystemManagerTest, remove_theme_with_properties)
@@ -113,7 +113,7 @@ TEST(DesignSystemManagerTest, remove_theme_with_properties)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 0),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 0),
                       Not(HasProperty(*themeId, GroupType::Colors, testProp))));
 }
 
@@ -126,7 +126,7 @@ TEST_P(DesignSystemManagerTest, add_property_without_theme)
     mgr.addProperty(groupType, testProp);
 
     //assert
-    ASSERT_THAT(mgr, Property(&DSThemeManager::themeCount, 0));
+    ASSERT_THAT(mgr, Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 0));
 }
 
 TEST_P(DesignSystemManagerTest, add_property)
@@ -140,7 +140,7 @@ TEST_P(DesignSystemManagerTest, add_property)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       HasProperty(*themeId, groupType, testProp)));
 }
 
@@ -156,7 +156,7 @@ TEST_P(DesignSystemManagerTest, adding_invalid_property_fails)
     // assert
     ASSERT_FALSE(result);
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       Not(HasProperty(*themeId, groupType, testProp))));
 }
 
@@ -172,7 +172,7 @@ TEST_P(DesignSystemManagerTest, adding_property_adds_property_to_all_themes)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 2),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 2),
                       HasProperty(*themeIdDark, groupType, testProp),
                       HasProperty(*themeIdLight, groupType, testProp)));
 }
@@ -190,7 +190,7 @@ TEST_P(DesignSystemManagerTest, update_property_value)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       HasProperty(*themeId, groupType, testPropUpdated)));
 }
 
@@ -207,7 +207,7 @@ TEST_P(DesignSystemManagerTest, update_property_name)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       HasProperty(*themeId, groupType, testPropUpdated)));
 }
 
@@ -224,7 +224,7 @@ TEST_P(DesignSystemManagerTest, updating_invalid_property_fails)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       HasProperty(*themeId, groupType, testProp)));
 }
 
@@ -240,7 +240,7 @@ TEST_P(DesignSystemManagerTest, remove_property)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       Not(HasProperty(*themeId, groupType, testProp))));
 }
 
@@ -256,7 +256,7 @@ TEST_P(DesignSystemManagerTest, remove_absent_property_fails)
 
     // assert
     ASSERT_THAT(mgr,
-                AllOf(Property(&DSThemeManager::themeCount, 1),
+                AllOf(Property("DSThemeManager::themeCount", &DSThemeManager::themeCount, 1),
                       HasProperty(*themeId, groupType, testProp)));
 }
 } // namespace
diff --git a/tests/unit/tests/unittests/designsystem/dsthemeqml-test.cpp b/tests/unit/tests/unittests/designsystem/dsthemeqml-test.cpp
index 5951ee830c0..2fa8de50705 100644
--- a/tests/unit/tests/unittests/designsystem/dsthemeqml-test.cpp
+++ b/tests/unit/tests/unittests/designsystem/dsthemeqml-test.cpp
@@ -134,7 +134,7 @@ TEST_P(DesignSystemQmlTest, group_aliase_properties_are_generated)
 
     // assert
     ASSERT_THAT(rootNode,
-                AllOf(Property(&ModelNode::type, Eq("QtObject")),
+                AllOf(Property("ModelNode::type", &ModelNode::type, Eq("QtObject")),
                       HasBindingProperty(groupName, binding),
                       HasBindingProperty("currentTheme", darkThemeName),
                       HasNodeProperty(darkThemeName, "QtObject")));
@@ -152,7 +152,7 @@ TEST_P(DesignSystemQmlTest, empty_groups_generate_no_group_aliase_properties)
 
     // assert
     ASSERT_THAT(rootNode,
-                AllOf(Property(&ModelNode::type, Eq("QtObject")),
+                AllOf(Property("ModelNode::type", &ModelNode::type, Eq("QtObject")),
                       Not(HasBindingProperty(groupName, binding)),
                       Not(HasBindingProperty("currentTheme", darkThemeName)),
                       Not(HasNodeProperty(darkThemeName, "QtObject"))));
diff --git a/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp b/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
index 7dd283579d5..c474b1d34b6 100644
--- a/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/asynchronousimagecache-test.cpp
@@ -519,9 +519,9 @@ TEST_F(AsynchronousImageCache, request_image_with_auxiliary_data_request_image_f
                               _,
                               _,
                               VariantWith<FontCollectorSizesAuxiliaryData>(
-                                  AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                  AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                               ElementsAre(QSize{20, 11})),
-                                        Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                        Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                               Eq(u"color")))),
                               _))
         .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
@@ -548,9 +548,9 @@ TEST_F(AsynchronousImageCache, request_mid_size_image_with_auxiliary_data_reques
                               _,
                               _,
                               VariantWith<FontCollectorSizesAuxiliaryData>(
-                                  AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                  AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                               ElementsAre(QSize{20, 11})),
-                                        Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                        Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                               Eq(u"color")))),
                               _))
         .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
@@ -577,9 +577,9 @@ TEST_F(AsynchronousImageCache, request_small_image_with_auxiliary_data_request_i
                               _,
                               _,
                               VariantWith<FontCollectorSizesAuxiliaryData>(
-                                  AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                  AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                               ElementsAre(QSize{20, 11})),
-                                        Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                        Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                               Eq(u"color")))),
                               _))
         .WillRepeatedly([&](auto, auto, auto, auto &&, auto, auto, auto) { notification.notify(); });
diff --git a/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp b/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
index 966d18f95e6..a8f5cb05976 100644
--- a/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/asynchronousimagefactory-test.cpp
@@ -74,10 +74,10 @@ TEST_F(AsynchronousImageFactory, request_image_with_auxiliary_data_request_image
                 start(Eq("/path/to/Component.qml"),
                       Eq("foo"),
                       VariantWith<FontCollectorSizesAuxiliaryData>(
-                          AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                          AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                       ElementsAre(QSize{20, 11})),
-                                Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")),
-                                Field(&FontCollectorSizesAuxiliaryData::text, Eq(u"some text")))),
+                                Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")),
+                                Field("FontCollectorSizesAuxiliaryData::text", &FontCollectorSizesAuxiliaryData::text, Eq(u"some text")))),
                       _,
                       _,
                       _))
diff --git a/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp b/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
index b463a5a698e..00f4b43a051 100644
--- a/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/imagecachedispatchcollector-test.cpp
@@ -90,9 +90,9 @@ TEST_F(ImageCacheDispatchCollector, call_qml_collector_start)
                 start(Eq("foo.qml"),
                       Eq("state"),
                       VariantWith<FontCollectorSizesAuxiliaryData>(
-                          AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                          AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                       ElementsAre(QSize{20, 11})),
-                                Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
+                                Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
                       _,
                       _,
                       _))
@@ -128,9 +128,9 @@ TEST_F(ImageCacheDispatchCollector, call_ui_file_collector_start)
                 start(Eq("foo.ui.qml"),
                       Eq("state"),
                       VariantWith<FontCollectorSizesAuxiliaryData>(
-                          AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                          AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                       ElementsAre(QSize{20, 11})),
-                                Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
+                                Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
                       _,
                       _,
                       _))
@@ -206,9 +206,9 @@ TEST_F(ImageCacheDispatchCollector, first_collector_create_icon_calls)
                 createIcon(Eq("foo.ui.qml"),
                            Eq("state"),
                            VariantWith<FontCollectorSizesAuxiliaryData>(
-                               AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                               AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                            ElementsAre(QSize{20, 11})),
-                                     Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                     Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                            Eq(u"color"))))));
     EXPECT_CALL(collectorMock2, createIcon(_, _, _)).Times(0);
 
@@ -252,9 +252,9 @@ TEST_F(ImageCacheDispatchCollector, second_collector_create_icon_calls)
                 createIcon(Eq("foo.qml"),
                            Eq("state"),
                            VariantWith<FontCollectorSizesAuxiliaryData>(
-                               AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                               AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                            ElementsAre(QSize{20, 11})),
-                                     Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                     Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                            Eq(u"color"))))));
     EXPECT_CALL(collectorMock1, createIcon(_, _, _)).Times(0);
 
@@ -317,9 +317,9 @@ TEST_F(ImageCacheDispatchCollector, first_collector_create_image_calls)
                 createImage(Eq("foo.ui.qml"),
                             Eq("state"),
                             VariantWith<FontCollectorSizesAuxiliaryData>(
-                                AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                             ElementsAre(QSize{20, 11})),
-                                      Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                      Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                             Eq(u"color"))))));
     EXPECT_CALL(collectorMock2, createImage(_, _, _)).Times(0);
 
@@ -363,9 +363,9 @@ TEST_F(ImageCacheDispatchCollector, second_collector_create_image_calls)
                 createImage(Eq("foo.qml"),
                             Eq("state"),
                             VariantWith<FontCollectorSizesAuxiliaryData>(
-                                AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                             ElementsAre(QSize{20, 11})),
-                                      Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                      Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                             Eq(u"color"))))));
     EXPECT_CALL(collectorMock1, createImage(_, _, _)).Times(0);
 
diff --git a/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp b/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
index 15e31764ad7..f58a237d60c 100644
--- a/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/imagecachegenerator-test.cpp
@@ -421,9 +421,9 @@ TEST_F(ImageCacheGenerator, calls_collector_with_auxiliary_data)
                 start(Eq("name"),
                       _,
                       VariantWith<FontCollectorSizesAuxiliaryData>(
-                          AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                          AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                       ElementsAre(QSize{20, 11})),
-                                Field(&FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
+                                Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName, Eq(u"color")))),
                       _,
                       _,
                       _))
diff --git a/tests/unit/tests/unittests/imagecache/synchronousimagecache-test.cpp b/tests/unit/tests/unittests/imagecache/synchronousimagecache-test.cpp
index 0f6a053988a..c2719bbe8ef 100644
--- a/tests/unit/tests/unittests/imagecache/synchronousimagecache-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/synchronousimagecache-test.cpp
@@ -240,9 +240,9 @@ TEST_F(SynchronousImageCache, icon_calls_collector_with_auxiliary_data)
                 createIcon(Eq("/path/to/Component.qml"),
                            Eq("extraId1"),
                            VariantWith<FontCollectorSizesAuxiliaryData>(
-                               AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                               AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                            ElementsAre(QSize{20, 11})),
-                                     Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                     Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                            Eq(u"color"))))));
 
     auto icon = cache.icon("/path/to/Component.qml",
@@ -261,9 +261,9 @@ TEST_F(SynchronousImageCache, image_calls_collector_with_auxiliary_data)
                 createImage(Eq("/path/to/Component.qml"),
                             Eq("extraId1"),
                             VariantWith<FontCollectorSizesAuxiliaryData>(
-                                AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                             ElementsAre(QSize{20, 11})),
-                                      Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                      Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                             Eq(u"color"))))));
 
     auto icon = cache.image("/path/to/Component.qml",
@@ -282,9 +282,9 @@ TEST_F(SynchronousImageCache, small_image_calls_collector_with_auxiliary_data)
                 createImage(Eq("/path/to/Component.qml"),
                             Eq("extraId1"),
                             VariantWith<FontCollectorSizesAuxiliaryData>(
-                                AllOf(Field(&FontCollectorSizesAuxiliaryData::sizes,
+                                AllOf(Field("FontCollectorSizesAuxiliaryData::sizes", &FontCollectorSizesAuxiliaryData::sizes,
                                             ElementsAre(QSize{20, 11})),
-                                      Field(&FontCollectorSizesAuxiliaryData::colorName,
+                                      Field("FontCollectorSizesAuxiliaryData::colorName", &FontCollectorSizesAuxiliaryData::colorName,
                                             Eq(u"color"))))));
 
     auto icon = cache.smallImage("/path/to/Component.qml",
diff --git a/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp b/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
index ea295c57332..0fd682875e0 100644
--- a/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
+++ b/tests/unit/tests/unittests/imagecache/taskqueue-test.cpp
@@ -21,7 +21,7 @@ struct Task
 template<typename Matcher>
 auto IsTask(Matcher matcher)
 {
-    return Field(&Task::i, matcher);
+    return Field("Task::i", &Task::i, matcher);
 }
 
 class TaskQueue : public testing::Test
diff --git a/tests/unit/tests/unittests/listmodeleditor/listmodeleditor-test.cpp b/tests/unit/tests/unittests/listmodeleditor/listmodeleditor-test.cpp
index 0fc335b551a..2e8de03cbd2 100644
--- a/tests/unit/tests/unittests/listmodeleditor/listmodeleditor-test.cpp
+++ b/tests/unit/tests/unittests/listmodeleditor/listmodeleditor-test.cpp
@@ -303,10 +303,10 @@ TEST_F(ListModelEditor, add_row_creates_new_model_node_and_reparents)
 {
     model.setListModel(listModelNode);
 
-    EXPECT_CALL(mockView, nodeCreated(Property(&ModelNode::type, Eq("ListElement"))));
+    EXPECT_CALL(mockView, nodeCreated(Property("ModelNode::type", &ModelNode::type, Eq("ListElement"))));
     EXPECT_CALL(mockView,
-                nodeReparented(Property(&ModelNode::type, Eq("ListElement")),
-                               Property(&AbstractProperty::parentModelNode, Eq(listModelNode)),
+                nodeReparented(Property("ModelNode::type", &ModelNode::type, Eq("ListElement")),
+                               Property("AbstractProperty::parentModelNode", &AbstractProperty::parentModelNode, Eq(listModelNode)),
                                _,
                                _));
 
diff --git a/tests/unit/tests/unittests/metainfo/nodemetainfo-test.cpp b/tests/unit/tests/unittests/metainfo/nodemetainfo-test.cpp
index 5b957f15b8d..cbdad30c031 100644
--- a/tests/unit/tests/unittests/metainfo/nodemetainfo-test.cpp
+++ b/tests/unit/tests/unittests/metainfo/nodemetainfo-test.cpp
@@ -24,7 +24,7 @@ using QmlDesigner::Storage::TypeTraitsKind;
 template<typename Matcher>
 auto PropertyId(const Matcher &matcher)
 {
-    return Property(&QmlDesigner::PropertyMetaInfo::id, matcher);
+    return Property("QmlDesigner::PropertyMetaInfo::id", &QmlDesigner::PropertyMetaInfo::id, matcher);
 }
 
 template<typename PropertyMatcher, typename ParentPropertyMatcher, typename NameMatcher>
@@ -32,9 +32,15 @@ auto CompoundProperty(const PropertyMatcher &propertyMatcher,
                       const ParentPropertyMatcher &parentPropertyMatcher,
                       const NameMatcher &nameMatcher)
 {
-    return AllOf(Field(&QmlDesigner::CompoundPropertyMetaInfo::property, propertyMatcher),
-                 Field(&QmlDesigner::CompoundPropertyMetaInfo::parent, parentPropertyMatcher),
-                 Property(&QmlDesigner::CompoundPropertyMetaInfo::name, nameMatcher));
+    return AllOf(Field("QmlDesigner::CompoundPropertyMetaInfo::property",
+                       &QmlDesigner::CompoundPropertyMetaInfo::property,
+                       propertyMatcher),
+                 Field("QmlDesigner::CompoundPropertyMetaInfo::parent",
+                       &QmlDesigner::CompoundPropertyMetaInfo::parent,
+                       parentPropertyMatcher),
+                 Property("QmlDesigner::CompoundPropertyMetaInfo::name",
+                          &QmlDesigner::CompoundPropertyMetaInfo::name,
+                          nameMatcher));
 }
 
 template<typename PropertyIdMatcher, typename ParentPropertyIdMatcher, typename NameMatcher>
diff --git a/tests/unit/tests/unittests/model/auxiliarypropertystorageview-test.cpp b/tests/unit/tests/unittests/model/auxiliarypropertystorageview-test.cpp
index a7d68390032..2021ca4f5c7 100644
--- a/tests/unit/tests/unittests/model/auxiliarypropertystorageview-test.cpp
+++ b/tests/unit/tests/unittests/model/auxiliarypropertystorageview-test.cpp
@@ -19,8 +19,8 @@ using QmlDesigner::ModelNode;
 template<typename NameMatcher>
 auto AuxiliaryProperty(AuxiliaryDataType type, const NameMatcher &nameMatcher, const QVariant &value)
 {
-    return Pair(AllOf(Field(&AuxiliaryDataKey::type, type),
-                      Field(&AuxiliaryDataKey::name, nameMatcher)),
+    return Pair(AllOf(Field("AuxiliaryDataKey::type", &AuxiliaryDataKey::type, type),
+                      Field("AuxiliaryDataKey::name", &AuxiliaryDataKey::name, nameMatcher)),
                 value);
 }
 
diff --git a/tests/unit/tests/unittests/projectstorage/modulescanner-test.cpp b/tests/unit/tests/unittests/projectstorage/modulescanner-test.cpp
index b3f09e9b6bf..4bd8d8b7092 100644
--- a/tests/unit/tests/unittests/projectstorage/modulescanner-test.cpp
+++ b/tests/unit/tests/unittests/projectstorage/modulescanner-test.cpp
@@ -15,13 +15,13 @@ QLatin1String qmlModulesPath(UNITTEST_DIR "/projectstorage/data/qml");
 template<typename Matcher>
 auto UrlProperty(const Matcher &matcher)
 {
-    return Property(&QmlDesigner::Import::url, matcher);
+    return Property("QmlDesigner::Import::url", &QmlDesigner::Import::url, matcher);
 }
 
 template<typename Matcher>
 auto VersionProperty(const Matcher &matcher)
 {
-    return Property(&QmlDesigner::Import::version, matcher);
+    return Property("QmlDesigner::Import::version", &QmlDesigner::Import::version, matcher);
 }
 
 template<typename Matcher>
diff --git a/tests/unit/tests/unittests/projectstorage/projectstorage-test.cpp b/tests/unit/tests/unittests/projectstorage/projectstorage-test.cpp
index c8dbb7ed618..94b7ac5b9a5 100644
--- a/tests/unit/tests/unittests/projectstorage/projectstorage-test.cpp
+++ b/tests/unit/tests/unittests/projectstorage/projectstorage-test.cpp
@@ -52,8 +52,8 @@ Storage::Imports operator+(const Storage::Imports &first,
 
 auto IsModule(Utils::SmallStringView name, ModuleKind kind)
 {
-    return AllOf(Field(&QmlDesigner::Storage::Module::name, name),
-                 Field(&QmlDesigner::Storage::Module::kind, kind));
+    return AllOf(Field("QmlDesigner::Storage::Module::name", &QmlDesigner::Storage::Module::name, name),
+                 Field("QmlDesigner::Storage::Module::kind", &QmlDesigner::Storage::Module::kind, kind));
 }
 
 MATCHER_P4(IsStorageType,
@@ -142,8 +142,11 @@ template<typename PropertyTypeIdMatcher>
 auto IsPropertyDeclaration(Utils::SmallStringView name,
                            const PropertyTypeIdMatcher &propertyTypeIdMatcher)
 {
-    return AllOf(Field(&Storage::Synchronization::PropertyDeclaration::name, name),
-                 Field(&Storage::Synchronization::PropertyDeclaration::propertyTypeId,
+    return AllOf(Field("PropertyDeclaration::name",
+                       &Storage::Synchronization::PropertyDeclaration::name,
+                       name),
+                 Field("PropertyDeclaration::propertyTypeId",
+                       &Storage::Synchronization::PropertyDeclaration::propertyTypeId,
                        propertyTypeIdMatcher));
 }
 
@@ -152,10 +155,15 @@ auto IsPropertyDeclaration(Utils::SmallStringView name,
                            const PropertyTypeIdMatcher &propertyTypeIdMatcher,
                            TraitsMatcher traitsMatcher)
 {
-    return AllOf(Field(&Storage::Synchronization::PropertyDeclaration::name, name),
-                 Field(&Storage::Synchronization::PropertyDeclaration::propertyTypeId,
+    return AllOf(Field("PropertyDeclaration::name",
+                       &Storage::Synchronization::PropertyDeclaration::name,
+                       name),
+                 Field("PropertyDeclaration::propertyTypeId",
+                       &Storage::Synchronization::PropertyDeclaration::propertyTypeId,
                        propertyTypeIdMatcher),
-                 Field(&Storage::Synchronization::PropertyDeclaration::traits, traitsMatcher));
+                 Field("PropertyDeclaration::traits",
+                       &Storage::Synchronization::PropertyDeclaration::traits,
+                       traitsMatcher));
 }
 
 template<typename PropertyTypeIdMatcher, typename TraitsMatcher>
@@ -164,11 +172,17 @@ auto IsPropertyDeclaration(Utils::SmallStringView name,
                            TraitsMatcher traitsMatcher,
                            Utils::SmallStringView aliasPropertyName)
 {
-    return AllOf(Field(&Storage::Synchronization::PropertyDeclaration::name, name),
-                 Field(&Storage::Synchronization::PropertyDeclaration::propertyTypeId,
+    return AllOf(Field("PropertyDeclaration::name",
+                       &Storage::Synchronization::PropertyDeclaration::name,
+                       name),
+                 Field("PropertyDeclaration::propertyTypeId",
+                       &Storage::Synchronization::PropertyDeclaration::propertyTypeId,
                        propertyTypeIdMatcher),
-                 Field(&Storage::Synchronization::PropertyDeclaration::traits, traitsMatcher),
-                 Field(&Storage::Synchronization::PropertyDeclaration::aliasPropertyName,
+                 Field("PropertyDeclaration::traits",
+                       &Storage::Synchronization::PropertyDeclaration::traits,
+                       traitsMatcher),
+                 Field("PropertyDeclaration::aliasPropertyName",
+                       &Storage::Synchronization::PropertyDeclaration::aliasPropertyName,
                        aliasPropertyName));
 }
 
@@ -178,61 +192,73 @@ auto IsInfoPropertyDeclaration(TypeId typeId,
                                TraitsMatcher traitsMatcher,
                                const PropertyTypeIdMatcher &propertyTypeIdMatcher)
 {
-    return AllOf(Field(&Storage::Info::PropertyDeclaration::typeId, typeId),
-                 Field(&Storage::Info::PropertyDeclaration::name, name),
-                 Field(&Storage::Info::PropertyDeclaration::propertyTypeId, propertyTypeIdMatcher),
-                 Field(&Storage::Info::PropertyDeclaration::traits, traitsMatcher));
+    return AllOf(Field("PropertyDeclaration::typeId", &Storage::Info::PropertyDeclaration::typeId, typeId),
+                 Field("PropertyDeclaration::name", &Storage::Info::PropertyDeclaration::name, name),
+                 Field("PropertyDeclaration::propertyTypeId",
+                       &Storage::Info::PropertyDeclaration::propertyTypeId,
+                       propertyTypeIdMatcher),
+                 Field("PropertyDeclaration::traits",
+                       &Storage::Info::PropertyDeclaration::traits,
+                       traitsMatcher));
 }
 
 auto IsUnresolvedTypeId()
 {
-    return Property(&QmlDesigner::TypeId::internalId, -1);
+    return Property("QmlDesigner::TypeId::internalId", &QmlDesigner::TypeId::internalId, -1);
 }
 
 auto IsNullTypeId()
 {
-    return Property(&QmlDesigner::TypeId::isNull, true);
+    return Property("QmlDesigner::TypeId::isNull", &QmlDesigner::TypeId::isNull, true);
 }
 
 auto IsNullPropertyDeclarationId()
 {
-    return Property(&QmlDesigner::PropertyDeclarationId::isNull, true);
+    return Property("QmlDesigner::PropertyDeclarationId::isNull",
+                    &QmlDesigner::PropertyDeclarationId::isNull,
+                    true);
 }
 
 template<typename Matcher>
 auto HasPrototypeId(const Matcher &matcher)
 {
-    return Field(&Storage::Synchronization::Type::prototypeId, matcher);
+    return Field("Type::prototypeId", &Storage::Synchronization::Type::prototypeId, matcher);
 }
 
 template<typename Matcher>
 auto HasExtensionId(const Matcher &matcher)
 {
-    return Field(&Storage::Synchronization::Type::extensionId, matcher);
+    return Field("Type::extensionId", &Storage::Synchronization::Type::extensionId, matcher);
 }
 
 template<typename Matcher>
 auto PropertyDeclarations(const Matcher &matcher)
 {
-    return Field(&Storage::Synchronization::Type::propertyDeclarations, matcher);
+    return Field("Type::propertyDeclarations",
+                 &Storage::Synchronization::Type::propertyDeclarations,
+                 matcher);
 }
 
 template<typename Matcher>
 auto HasPropertyTypeId(const Matcher &matcher)
 {
-    return Field(&Storage::Synchronization::PropertyDeclaration::propertyTypeId, matcher);
+    return Field("PropertyDeclaration::propertyTypeId",
+                 &Storage::Synchronization::PropertyDeclaration::propertyTypeId,
+                 matcher);
 }
 
 template<typename Matcher>
 auto HasTypeName(const Matcher &matcher)
 {
-    return Field(&Storage::Synchronization::Type::typeName, matcher);
+    return Field("Type::typeName", &Storage::Synchronization::Type::typeName, matcher);
 }
 
 template<typename Matcher>
 auto HasDefaultPropertyName(const Matcher &matcher)
 {
-    return Field(&Storage::Synchronization::Type::defaultPropertyName, matcher);
+    return Field("Type::defaultPropertyName",
+                 &Storage::Synchronization::Type::defaultPropertyName,
+                 matcher);
 }
 
 class HasNameMatcher
@@ -1264,7 +1290,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1272,7 +1299,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1288,7 +1316,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_with_extension_chain)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1297,7 +1326,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_with_extension_chain)
                                         TypeId{},
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1314,7 +1344,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_with_exported_prototype_
         storage.fetchTypes(),
         UnorderedElementsAre(
             AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeId{}, TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                              IsExportedType(qmlModuleId, "Obj"),
                                              IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1323,7 +1354,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_with_exported_prototype_
                                 fetchTypeId(sourceId2, "QObject"),
                                 TypeId{},
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
@@ -1339,7 +1371,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_with_exported_extension_
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1348,7 +1381,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_with_exported_extension_
                                         TypeId{},
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1557,7 +1591,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_reverse_order)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1565,7 +1600,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_new_types_reverse_order)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1583,7 +1619,8 @@ TEST_F(ProjectStorage, synchronize_types_overwrites_type_traits)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Value),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1591,7 +1628,8 @@ TEST_F(ProjectStorage, synchronize_types_overwrites_type_traits)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Value),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1618,7 +1656,8 @@ TEST_F(ProjectStorage, synchronize_types_overwrites_sources)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId4, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1626,7 +1665,8 @@ TEST_F(ProjectStorage, synchronize_types_overwrites_sources)
                                         "QQuickItem",
                                         fetchTypeId(sourceId4, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1653,7 +1693,8 @@ TEST_F(ProjectStorage, synchronize_types_insert_type_into_prototype_chain)
         storage.fetchTypes(),
         UnorderedElementsAre(
             AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeId{}, TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                              IsExportedType(qmlModuleId, "Obj"),
                                              IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1662,7 +1703,8 @@ TEST_F(ProjectStorage, synchronize_types_insert_type_into_prototype_chain)
                                 fetchTypeId(sourceId2, "QObject"),
                                 TypeId{},
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Object"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickObject")))),
             AllOf(IsStorageType(sourceId1,
@@ -1670,7 +1712,8 @@ TEST_F(ProjectStorage, synchronize_types_insert_type_into_prototype_chain)
                                 fetchTypeId(sourceId1, "QQuickObject"),
                                 TypeId{},
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
@@ -1697,7 +1740,8 @@ TEST_F(ProjectStorage, synchronize_types_insert_type_into_extension_chain)
         storage.fetchTypes(),
         UnorderedElementsAre(
             AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeId{}, TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                              IsExportedType(qmlModuleId, "Obj"),
                                              IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1706,7 +1750,8 @@ TEST_F(ProjectStorage, synchronize_types_insert_type_into_extension_chain)
                                 TypeId{},
                                 fetchTypeId(sourceId2, "QObject"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Object"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickObject")))),
             AllOf(IsStorageType(sourceId1,
@@ -1714,7 +1759,8 @@ TEST_F(ProjectStorage, synchronize_types_insert_type_into_extension_chain)
                                 TypeId{},
                                 fetchTypeId(sourceId1, "QQuickObject"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
@@ -1739,7 +1785,8 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_prototype)
         storage.fetchTypes(),
         UnorderedElementsAre(
             AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeId{}, TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                              IsExportedType(qmlModuleId, "Obj"),
                                              IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1748,7 +1795,8 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_prototype)
                                 fetchTypeId(sourceId2, "QObject"),
                                 TypeId{},
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Object"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickObject")))),
             AllOf(IsStorageType(sourceId1,
@@ -1756,7 +1804,8 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_prototype)
                                 fetchTypeId(sourceId1, "QQuickObject"),
                                 TypeId{},
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
@@ -1782,7 +1831,8 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_extension)
         storage.fetchTypes(),
         UnorderedElementsAre(
             AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeId{}, TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                              IsExportedType(qmlModuleId, "Obj"),
                                              IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1791,7 +1841,8 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_extension)
                                 TypeId{},
                                 fetchTypeId(sourceId2, "QObject"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Object"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickObject")))),
             AllOf(IsStorageType(sourceId1,
@@ -1799,7 +1850,8 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_extension)
                                 TypeId{},
                                 fetchTypeId(sourceId1, "QQuickObject"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
+                  Field("Type::exportedTypes",
+                        &Storage::Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                              IsExportedType(qtQuickNativeModuleId, "QQuickItem"))))));
 }
@@ -1878,7 +1930,8 @@ TEST_F(ProjectStorage, delete_type_if_source_id_is_synchronized)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject"))))));
@@ -1894,7 +1947,8 @@ TEST_F(ProjectStorage, dont_delete_type_if_source_id_is_not_synchronized)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1902,7 +1956,8 @@ TEST_F(ProjectStorage, dont_delete_type_if_source_id_is_not_synchronized)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -1919,7 +1974,8 @@ TEST_F(ProjectStorage, update_exported_types_if_type_name_changes)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -1927,7 +1983,8 @@ TEST_F(ProjectStorage, update_exported_types_if_type_name_changes)
                                         "QQuickItem2",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -2021,7 +2078,8 @@ TEST_F(ProjectStorage, synchronize_types_add_property_declarations)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
                                                           fetchTypeId(sourceId2, "QObject"),
@@ -2090,7 +2148,8 @@ TEST_F(ProjectStorage, synchronize_types_add_property_declaration_qualified_type
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
                                                           fetchTypeId(sourceId1, "QQuickObject"),
@@ -2117,7 +2176,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_property_declaration_type)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -2141,7 +2201,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_declaration_traits)
         storage.fetchTypes(),
         Contains(AllOf(
             IsStorageType(sourceId1, "QQuickItem", fetchTypeId(sourceId2, "QObject"), TypeTraitsKind::Reference),
-            Field(&Storage::Synchronization::Type::propertyDeclarations,
+            Field("Type::propertyDeclarations",
+                  &Storage::Synchronization::Type::propertyDeclarations,
                   UnorderedElementsAre(
                       IsPropertyDeclaration("data",
                                             fetchTypeId(sourceId2, "QObject"),
@@ -2166,7 +2227,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_declaration_traits_and_type)
         storage.fetchTypes(),
         Contains(AllOf(
             IsStorageType(sourceId1, "QQuickItem", fetchTypeId(sourceId2, "QObject"), TypeTraitsKind::Reference),
-            Field(&Storage::Synchronization::Type::propertyDeclarations,
+            Field("Type::propertyDeclarations",
+                  &Storage::Synchronization::Type::propertyDeclarations,
                   UnorderedElementsAre(
                       IsPropertyDeclaration("data",
                                             fetchTypeId(sourceId1, "QQuickItem"),
@@ -2190,7 +2252,8 @@ TEST_F(ProjectStorage, synchronize_types_removes_a_property_declaration)
                                              "QQuickItem",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      UnorderedElementsAre(IsPropertyDeclaration(
                                          "data",
                                          fetchTypeId(sourceId2, "QObject"),
@@ -2213,7 +2276,8 @@ TEST_F(ProjectStorage, synchronize_types_adds_a_property_declaration)
         storage.fetchTypes(),
         Contains(AllOf(
             IsStorageType(sourceId1, "QQuickItem", fetchTypeId(sourceId2, "QObject"), TypeTraitsKind::Reference),
-            Field(&Storage::Synchronization::Type::propertyDeclarations,
+            Field("Type::propertyDeclarations",
+                  &Storage::Synchronization::Type::propertyDeclarations,
                   UnorderedElementsAre(
                       IsPropertyDeclaration("object",
                                             fetchTypeId(sourceId2, "QObject"),
@@ -2241,7 +2305,8 @@ TEST_F(ProjectStorage, synchronize_types_rename_a_property_declaration)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("data",
                                                           fetchTypeId(sourceId2, "QObject"),
@@ -2443,7 +2508,8 @@ TEST_F(ProjectStorage, synchronize_types_add_function_declarations)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2462,7 +2528,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_return_typ
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2481,7 +2548,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_name)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2500,7 +2568,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_pop_parame
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2520,7 +2589,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_append_par
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2539,7 +2609,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_change_par
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2558,7 +2629,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_change_par
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2578,7 +2650,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_function_declaration_change_par
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2597,7 +2670,8 @@ TEST_F(ProjectStorage, synchronize_types_removes_function_declaration)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]))))));
 }
 
@@ -2616,7 +2690,8 @@ TEST_F(ProjectStorage, synchronize_types_add_function_declaration)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]),
                                                      Eq(package.types[0].functionDeclarations[2]))))));
@@ -2636,7 +2711,8 @@ TEST_F(ProjectStorage, synchronize_types_add_function_declarations_with_overload
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]),
                                                      Eq(package.types[0].functionDeclarations[2]))))));
@@ -2657,7 +2733,8 @@ TEST_F(ProjectStorage, synchronize_types_function_declarations_adding_overload)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]),
                                                      Eq(package.types[0].functionDeclarations[2]))))));
@@ -2679,7 +2756,8 @@ TEST_F(ProjectStorage, synchronize_types_function_declarations_removing_overload
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::functionDeclarations,
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].functionDeclarations[0]),
                                                      Eq(package.types[0].functionDeclarations[1]))))));
 }
@@ -2696,7 +2774,8 @@ TEST_F(ProjectStorage, synchronize_types_add_signal_declarations)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2715,7 +2794,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_signal_declaration_name)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2734,7 +2814,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_signal_declaration_pop_paramete
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2754,7 +2835,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_signal_declaration_append_param
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2773,7 +2855,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_signal_declaration_change_param
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2792,7 +2875,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_signal_declaration_change_param
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2811,7 +2895,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_signal_declaration_change_param
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2830,7 +2915,8 @@ TEST_F(ProjectStorage, synchronize_types_removes_signal_declaration)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]))))));
 }
 
@@ -2849,7 +2935,8 @@ TEST_F(ProjectStorage, synchronize_types_add_signal_declaration)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]),
                                                      Eq(package.types[0].signalDeclarations[2]))))));
@@ -2869,7 +2956,8 @@ TEST_F(ProjectStorage, synchronize_types_add_signal_declarations_with_overloads)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]),
                                                      Eq(package.types[0].signalDeclarations[2]))))));
@@ -2890,7 +2978,8 @@ TEST_F(ProjectStorage, synchronize_types_signal_declarations_adding_overload)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]),
                                                      Eq(package.types[0].signalDeclarations[2]))))));
@@ -2912,7 +3001,8 @@ TEST_F(ProjectStorage, synchronize_types_signal_declarations_removing_overload)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::signalDeclarations,
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
                                 UnorderedElementsAre(Eq(package.types[0].signalDeclarations[0]),
                                                      Eq(package.types[0].signalDeclarations[1]))))));
 }
@@ -2929,7 +3019,8 @@ TEST_F(ProjectStorage, synchronize_types_add_enumeration_declarations)
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -2948,7 +3039,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_enumeration_declaration_name)
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -2967,7 +3059,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_enumeration_declaration_pop_enu
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -2987,7 +3080,8 @@ TEST_F(ProjectStorage, synchronize_types_changes_enumeration_declaration_append_
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -3007,7 +3101,8 @@ TEST_F(ProjectStorage,
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -3027,7 +3122,8 @@ TEST_F(ProjectStorage,
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -3048,7 +3144,8 @@ TEST_F(ProjectStorage,
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -3068,7 +3165,8 @@ TEST_F(ProjectStorage,
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]))))));
 }
@@ -3086,7 +3184,8 @@ TEST_F(ProjectStorage, synchronize_types_removes_enumeration_declaration)
                                              "QQuickItem",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                               Field("Type::enumerationDeclarations",
+                                     &Storage::Synchronization::Type::enumerationDeclarations,
                                      UnorderedElementsAre(
                                          Eq(package.types[0].enumerationDeclarations[0]))))));
 }
@@ -3106,7 +3205,8 @@ TEST_F(ProjectStorage, synchronize_types_add_enumeration_declaration)
                                   "QQuickItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::enumerationDeclarations,
+                    Field("Type::enumerationDeclarations",
+                          &Storage::Synchronization::Type::enumerationDeclarations,
                           UnorderedElementsAre(Eq(package.types[0].enumerationDeclarations[0]),
                                                Eq(package.types[0].enumerationDeclarations[1]),
                                                Eq(package.types[0].enumerationDeclarations[2]))))));
@@ -3186,7 +3286,8 @@ TEST_F(ProjectStorage, synchronize_types_add_alias_declarations)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3213,7 +3314,8 @@ TEST_F(ProjectStorage, synchronize_types_add_alias_declarations_again)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3241,7 +3343,8 @@ TEST_F(ProjectStorage, synchronize_types_remove_alias_declarations)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3351,7 +3454,8 @@ TEST_F(ProjectStorage, synchronize_types_change_alias_declarations_type_name)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3380,7 +3484,8 @@ TEST_F(ProjectStorage, synchronize_types_change_alias_declarations_property_name
                                 "QAliasItem",
                                 fetchTypeId(sourceId1, "QQuickItem"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::propertyDeclarations,
+                  Field("Type::propertyDeclarations",
+                        &Storage::Synchronization::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
                                                   fetchTypeId(sourceId1, "QQuickItem"),
@@ -3414,7 +3519,8 @@ TEST_F(ProjectStorage, synchronize_types_change_alias_declarations_to_property_d
                                 "QAliasItem",
                                 fetchTypeId(sourceId1, "QQuickItem"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::propertyDeclarations,
+                  Field("Type::propertyDeclarations",
+                        &Storage::Synchronization::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
                                                   fetchTypeId(sourceId1, "QQuickItem"),
@@ -3448,7 +3554,8 @@ TEST_F(ProjectStorage, synchronize_types_change_property_declarations_to_alias_d
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3478,7 +3585,8 @@ TEST_F(ProjectStorage, synchronize_types_change_alias_target_property_declaratio
                                 "QAliasItem",
                                 fetchTypeId(sourceId1, "QQuickItem"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::propertyDeclarations,
+                  Field("Type::propertyDeclarations",
+                        &Storage::Synchronization::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
                                                   fetchTypeId(sourceId1, "QQuickItem"),
@@ -3509,7 +3617,8 @@ TEST_F(ProjectStorage, synchronize_types_change_alias_target_property_declaratio
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3551,7 +3660,8 @@ TEST_F(ProjectStorage, synchronize_types_remove_property_declaration_and_alias)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3628,7 +3738,8 @@ TEST_F(ProjectStorage, synchronize_types_remove_type_and_alias_property_declarat
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3657,7 +3768,8 @@ TEST_F(ProjectStorage, update_alias_property_if_property_is_overloaded)
                                 "QAliasItem",
                                 fetchTypeId(sourceId1, "QQuickItem"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::propertyDeclarations,
+                  Field("Type::propertyDeclarations",
+                        &Storage::Synchronization::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
                                                   fetchTypeId(sourceId1, "QQuickItem"),
@@ -3689,7 +3801,8 @@ TEST_F(ProjectStorage, alias_property_is_overloaded)
                                 "QAliasItem",
                                 fetchTypeId(sourceId1, "QQuickItem"),
                                 TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::propertyDeclarations,
+                  Field("Type::propertyDeclarations",
+                        &Storage::Synchronization::Type::propertyDeclarations,
                         UnorderedElementsAre(
                             IsPropertyDeclaration("items",
                                                   fetchTypeId(sourceId1, "QQuickItem"),
@@ -3722,7 +3835,8 @@ TEST_F(ProjectStorage, update_alias_property_if_overloaded_property_is_removed)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3754,7 +3868,8 @@ TEST_F(ProjectStorage, relink_alias_property)
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3850,7 +3965,8 @@ TEST_F(ProjectStorage,
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -3880,7 +3996,8 @@ TEST_F(ProjectStorage, relink_alias_property_react_to_type_name_change)
                                   "QAliasItem",
                                   fetchTypeId(sourceId2, "QObject"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem2"),
@@ -4388,7 +4505,8 @@ TEST_F(ProjectStorage, recursive_aliases)
                                              "QAliasItem2",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
                                          fetchTypeId(sourceId2, "QObject"),
@@ -4410,7 +4528,8 @@ TEST_F(ProjectStorage, recursive_aliases_change_property_type)
                                              "QAliasItem2",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
                                          fetchTypeId(sourceId4, "QObject2"),
@@ -4433,7 +4552,8 @@ TEST_F(ProjectStorage, update_aliases_after_injecting_property)
                                              "QAliasItem2",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
                                          fetchTypeId(sourceId1, "QQuickItem"),
@@ -4458,7 +4578,8 @@ TEST_F(ProjectStorage, update_aliases_after_change_alias_to_property)
                                                    "QAliasItem2",
                                                    fetchTypeId(sourceId2, "QObject"),
                                                    TypeTraitsKind::Reference),
-                                     Field(&Storage::Synchronization::Type::propertyDeclarations,
+                                     Field("Type::propertyDeclarations",
+                                           &Storage::Synchronization::Type::propertyDeclarations,
                                            ElementsAre(IsPropertyDeclaration(
                                                "objects",
                                                fetchTypeId(sourceId1, "QQuickItem"),
@@ -4469,7 +4590,8 @@ TEST_F(ProjectStorage, update_aliases_after_change_alias_to_property)
                                                    "QAliasItem",
                                                    fetchTypeId(sourceId1, "QQuickItem"),
                                                    TypeTraitsKind::Reference),
-                                     Field(&Storage::Synchronization::Type::propertyDeclarations,
+                                     Field("Type::propertyDeclarations",
+                                           &Storage::Synchronization::Type::propertyDeclarations,
                                            ElementsAre(IsPropertyDeclaration(
                                                "objects",
                                                fetchTypeId(sourceId1, "QQuickItem"),
@@ -4496,7 +4618,8 @@ TEST_F(ProjectStorage, update_aliases_after_change_property_to_alias)
                                              "QAliasItem2",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      ElementsAre(IsPropertyDeclaration(
                                          "objects",
                                          fetchTypeId(sourceId2, "QObject"),
@@ -4859,7 +4982,8 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           Contains(IsPropertyDeclaration("data",
                                                          fetchTypeId(sourceId2, "QObject"),
                                                          Storage::PropertyDeclarationTraits::IsList)))));
@@ -4926,7 +5050,8 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name_in_the_module_ch
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           Contains(IsPropertyDeclaration("data",
                                                          fetchTypeId(sourceId3, "QQuickObject"),
                                                          Storage::PropertyDeclarationTraits::IsList)))));
@@ -4943,7 +5068,8 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name_with_version)
 
     ASSERT_THAT(storage.fetchTypes(),
                 Contains(
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           Contains(IsPropertyDeclaration("data",
                                                          fetchTypeId(sourceId2, "QObject"),
                                                          Storage::PropertyDeclarationTraits::IsList)))));
@@ -5019,7 +5145,8 @@ TEST_F(ProjectStorage, change_property_type_module_id_with_qualified_type)
                                              "QQuickItem",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      Contains(IsPropertyDeclaration(
                                          "data",
                                          fetchTypeId(sourceId2, "QObject"),
@@ -5116,7 +5243,8 @@ TEST_F(ProjectStorage, synchronize_types_without_type_name)
                                              "QObject2",
                                              fetchTypeId(sourceId2, "QObject"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::exportedTypes,
+                               Field("Type::exportedTypes",
+                                     &Storage::Synchronization::Type::exportedTypes,
                                      UnorderedElementsAre(IsExportedType("Object2"),
                                                           IsExportedType("Obj2"))))));
 }
@@ -5608,25 +5736,35 @@ TEST_F(ProjectStorage, minimal_updates)
 
     storage.synchronize(SynchronizationPackage{{quickType}});
 
-    ASSERT_THAT(
-        storage.fetchTypes(),
-        UnorderedElementsAre(
-            AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
-                        UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
-                                             IsExportedType(qmlModuleId, "Obj"),
-                                             IsExportedType(qmlNativeModuleId, "QObject")))),
-            AllOf(IsStorageType(sourceId1,
-                                "QQuickItem",
-                                fetchTypeId(sourceId2, "QObject"),
-                                TypeTraitsKind::Reference),
-                  Field(&Storage::Synchronization::Type::exportedTypes,
-                        UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item", 2, 0),
-                                             IsExportedType(qtQuickNativeModuleId, "QQuickItem"))),
-                  Field(&Storage::Synchronization::Type::propertyDeclarations, Not(IsEmpty())),
-                  Field(&Storage::Synchronization::Type::functionDeclarations, Not(IsEmpty())),
-                  Field(&Storage::Synchronization::Type::signalDeclarations, Not(IsEmpty())),
-                  Field(&Storage::Synchronization::Type::enumerationDeclarations, Not(IsEmpty())))));
+    ASSERT_THAT(storage.fetchTypes(),
+                UnorderedElementsAre(
+                    AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
+                                                     IsExportedType(qmlModuleId, "Obj"),
+                                                     IsExportedType(qmlNativeModuleId, "QObject")))),
+                    AllOf(IsStorageType(sourceId1,
+                                        "QQuickItem",
+                                        fetchTypeId(sourceId2, "QObject"),
+                                        TypeTraitsKind::Reference),
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item", 2, 0),
+                                                     IsExportedType(qtQuickNativeModuleId,
+                                                                    "QQuickItem"))),
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
+                                Not(IsEmpty())),
+                          Field("Type::functionDeclarations",
+                                &Storage::Synchronization::Type::functionDeclarations,
+                                Not(IsEmpty())),
+                          Field("Type::signalDeclarations",
+                                &Storage::Synchronization::Type::signalDeclarations,
+                                Not(IsEmpty())),
+                          Field("Type::enumerationDeclarations",
+                                &Storage::Synchronization::Type::enumerationDeclarations,
+                                Not(IsEmpty())))));
 }
 
 TEST_F(ProjectStorage, get_module_id)
@@ -5979,7 +6117,8 @@ TEST_F(ProjectStorage, exclude_exported_types)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -5987,7 +6126,8 @@ TEST_F(ProjectStorage, exclude_exported_types)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -6005,22 +6145,26 @@ TEST_F(ProjectStorage, module_exported_import)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item")))),
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object")))),
                     AllOf(IsStorageType(sourceId3,
                                         "QQuickItem3d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick3DModuleId, "Item3D")))),
                     AllOf(IsStorageType(sourceId4,
                                         "MyItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(myModuleModuleId, "MyItem"))))));
 }
 
@@ -6053,22 +6197,26 @@ TEST_F(ProjectStorage, module_exported_import_with_different_versions)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item")))),
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object")))),
                     AllOf(IsStorageType(sourceId3,
                                         "QQuickItem3d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick3DModuleId, "Item3D")))),
                     AllOf(IsStorageType(sourceId4,
                                         "MyItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(myModuleModuleId, "MyItem"))))));
 }
 
@@ -6090,22 +6238,26 @@ TEST_F(ProjectStorage, module_exported_import_with_indirect_different_versions)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item")))),
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object")))),
                     AllOf(IsStorageType(sourceId3,
                                         "QQuickItem3d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick3DModuleId, "Item3D")))),
                     AllOf(IsStorageType(sourceId4,
                                         "MyItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(myModuleModuleId, "MyItem"))))));
 }
 
@@ -6141,28 +6293,33 @@ TEST_F(ProjectStorage,
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item")))),
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object")))),
                     AllOf(IsStorageType(sourceId3,
                                         "QQuickItem3d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick3DModuleId, "Item3D")))),
                     AllOf(IsStorageType(sourceId5,
                                         "QQuickItem4d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick4DModuleId, "Item4D")))),
                     AllOf(IsStorageType(sourceId4,
                                         "MyItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(myModuleModuleId, "MyItem"))))));
 }
 
@@ -6182,7 +6339,8 @@ TEST_F(ProjectStorage, distinguish_between_import_kinds)
     ASSERT_THAT(storage.fetchTypes(),
                 UnorderedElementsAre(
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object"),
                                                      IsExportedType(qmlModuleId, "Obj"),
                                                      IsExportedType(qmlNativeModuleId, "QObject")))),
@@ -6190,7 +6348,8 @@ TEST_F(ProjectStorage, distinguish_between_import_kinds)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item"),
                                                      IsExportedType(qtQuickNativeModuleId,
                                                                     "QQuickItem"))))));
@@ -6209,22 +6368,26 @@ TEST_F(ProjectStorage, module_exported_import_distinguish_between_dependency_and
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item")))),
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object")))),
                     AllOf(IsStorageType(sourceId3,
                                         "QQuickItem3d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick3DModuleId, "Item3D")))),
                     AllOf(IsStorageType(sourceId4,
                                         "MyItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(myModuleModuleId, "MyItem"))))));
 }
 
@@ -6242,22 +6405,26 @@ TEST_F(ProjectStorage, module_exported_import_with_qualified_imported_type)
                                         "QQuickItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuickModuleId, "Item")))),
                     AllOf(IsStorageType(sourceId2, "QObject", TypeId{}, TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qmlModuleId, "Object")))),
                     AllOf(IsStorageType(sourceId3,
                                         "QQuickItem3d",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQuick3DModuleId, "Item3D")))),
                     AllOf(IsStorageType(sourceId4,
                                         "MyItem",
                                         fetchTypeId(sourceId2, "QObject"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                          Field("Type::exportedTypes",
+                                &Storage::Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(myModuleModuleId, "MyItem"))))));
 }
 
@@ -6273,7 +6440,8 @@ TEST_F(ProjectStorage, synchronize_types_add_indirect_alias_declarations)
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6298,7 +6466,8 @@ TEST_F(ProjectStorage, synchronize_types_add_indirect_alias_declarations_again)
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6323,7 +6492,8 @@ TEST_F(ProjectStorage, synchronize_types_remove_indirect_alias_declaration)
                                              "QAliasItem",
                                              fetchTypeId(sourceId1, "QQuickItem"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      UnorderedElementsAre(IsPropertyDeclaration(
                                          "items",
                                          fetchTypeId(sourceId1, "QQuickItem"),
@@ -6487,7 +6657,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_declaration_type_
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6516,7 +6687,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_declaration_tails
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6543,7 +6715,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_declarations_prop
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6570,7 +6743,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_declarations_prop
                                   "QAliasItem",
                                   fetchTypeId(sourceId1, "QQuickItem"),
                                   TypeTraitsKind::Reference),
-                    Field(&Storage::Synchronization::Type::propertyDeclarations,
+                    Field("Type::propertyDeclarations",
+                          &Storage::Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("items",
                                                     fetchTypeId(sourceId1, "QQuickItem"),
@@ -6599,7 +6773,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_declarations_to_p
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6636,7 +6811,8 @@ TEST_F(ProjectStorage, synchronize_types_change_property_declarations_to_indirec
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6665,7 +6841,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_target_property_d
                           "QAliasItem",
                           fetchTypeId(sourceId1, "QQuickItem"),
                           TypeTraitsKind::Reference),
-            Field(&Storage::Synchronization::Type::propertyDeclarations,
+            Field("Type::propertyDeclarations",
+                  &Storage::Synchronization::Type::propertyDeclarations,
                   UnorderedElementsAre(
                       IsPropertyDeclaration("items",
                                             fetchTypeId(sourceId1, "QQuickItem"),
@@ -6693,7 +6870,8 @@ TEST_F(ProjectStorage, synchronize_types_change_indirect_alias_target_property_d
                                         "QAliasItem",
                                         fetchTypeId(sourceId1, "QQuickItem"),
                                         TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations,
+                          Field("Type::propertyDeclarations",
+                                &Storage::Synchronization::Type::propertyDeclarations,
                                 UnorderedElementsAre(
                                     IsPropertyDeclaration("items",
                                                           fetchTypeId(sourceId1, "QQuickItem"),
@@ -6752,7 +6930,8 @@ TEST_F(ProjectStorage, synchronize_types_remove_property_declaration_and_indirec
                                              "QAliasItem",
                                              fetchTypeId(sourceId1, "QQuickItem"),
                                              TypeTraitsKind::Reference),
-                               Field(&Storage::Synchronization::Type::propertyDeclarations,
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
                                      UnorderedElementsAre(IsPropertyDeclaration(
                                          "items",
                                          fetchTypeId(sourceId1, "QQuickItem"),
@@ -6773,12 +6952,13 @@ TEST_F(ProjectStorage, synchronize_types_remove_property_declaration_and_indirec
                                                {sourceId1, sourceId3}});
 
     ASSERT_THAT(storage.fetchTypes(),
-                Contains(
-                    AllOf(IsStorageType(sourceId3,
-                                        "QAliasItem",
-                                        fetchTypeId(sourceId1, "QQuickItem"),
-                                        TypeTraitsKind::Reference),
-                          Field(&Storage::Synchronization::Type::propertyDeclarations, IsEmpty()))));
+                Contains(AllOf(IsStorageType(sourceId3,
+                                             "QAliasItem",
+                                             fetchTypeId(sourceId1, "QQuickItem"),
+                                             TypeTraitsKind::Reference),
+                               Field("Type::propertyDeclarations",
+                                     &Storage::Synchronization::Type::propertyDeclarations,
+                                     IsEmpty()))));
 }
 
 TEST_F(ProjectStorage, get_type_id)
diff --git a/tests/unit/tests/unittests/projectstorage/projectstorageupdater-test.cpp b/tests/unit/tests/unittests/projectstorage/projectstorageupdater-test.cpp
index 29bf214a105..0136fa7c343 100644
--- a/tests/unit/tests/unittests/projectstorage/projectstorageupdater-test.cpp
+++ b/tests/unit/tests/unittests/projectstorage/projectstorageupdater-test.cpp
@@ -30,16 +30,24 @@ using QmlDesigner::SourceId;
 using QmlDesigner::SourceNameId;
 namespace Storage = QmlDesigner::Storage;
 using QmlDesigner::IdPaths;
-using QmlDesigner::Storage::Import;
-using QmlDesigner::Storage::ModuleKind;
-using QmlDesigner::Storage::Synchronization::DirectoryInfo;
-using QmlDesigner::Storage::Synchronization::FileType;
-using QmlDesigner::Storage::Synchronization::IsAutoVersion;
-using QmlDesigner::Storage::Synchronization::ModuleExportedImport;
-using QmlDesigner::Storage::Synchronization::SynchronizationPackage;
-using QmlDesigner::Storage::TypeTraits;
-using QmlDesigner::Storage::TypeTraitsKind;
-using QmlDesigner::Storage::Version;
+using Storage::Import;
+using Storage::ModuleKind;
+using Storage::Synchronization::ChangeLevel;
+using Storage::Synchronization::DirectoryInfo;
+using Storage::Synchronization::DirectoryInfos;
+using Storage::Synchronization::ExportedType;
+using Storage::Synchronization::FileType;
+using Storage::Synchronization::ImportedType;
+using Storage::Synchronization::ImportedTypeName;
+using Storage::Synchronization::IsAutoVersion;
+using Storage::Synchronization::ModuleExportedImport;
+using Storage::Synchronization::PropertyDeclaration;
+using Storage::Synchronization::PropertyEditorQmlPath;
+using Storage::Synchronization::SynchronizationPackage;
+using Storage::Synchronization::Type;
+using Storage::TypeTraits;
+using Storage::TypeTraitsKind;
+using Storage::Version;
 
 MATCHER_P5(IsStorageType,
            typeName,
@@ -48,14 +56,12 @@ MATCHER_P5(IsStorageType,
            sourceId,
            changeLevel,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Synchronization::Type(
-                   typeName, prototype, traits, sourceId, changeLevel)))
+               + PrintToString(Type(typeName, prototype, traits, sourceId, changeLevel)))
 {
-    const Storage::Synchronization::Type &type = arg;
+    const Type &type = arg;
 
     return type.typeName == typeName && type.traits == traits && type.sourceId == sourceId
-           && Storage::Synchronization::ImportedTypeName{prototype} == type.prototype
-           && type.changeLevel == changeLevel;
+           && ImportedTypeName{prototype} == type.prototype && type.changeLevel == changeLevel;
 }
 
 MATCHER_P3(IsPropertyDeclaration,
@@ -63,25 +69,25 @@ MATCHER_P3(IsPropertyDeclaration,
            typeName,
            traits,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Synchronization::PropertyDeclaration{name, typeName, traits}))
+               + PrintToString(PropertyDeclaration{name, typeName, traits}))
 {
-    const Storage::Synchronization::PropertyDeclaration &propertyDeclaration = arg;
+    const PropertyDeclaration &propertyDeclaration = arg;
 
     return propertyDeclaration.name == name
-           && Storage::Synchronization::ImportedTypeName{typeName} == propertyDeclaration.typeName
+           && ImportedTypeName{typeName} == propertyDeclaration.typeName
            && propertyDeclaration.traits == traits;
 }
 
-MATCHER_P4(IsExportedType,
-           moduleId,
-           name,
-           majorVersion,
-           minorVersion,
-           std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Synchronization::ExportedType{
-                   moduleId, name, Storage::Version{majorVersion, minorVersion}}))
+MATCHER_P4(
+    IsExportedType,
+    moduleId,
+    name,
+    majorVersion,
+    minorVersion,
+    std::string(negation ? "isn't " : "is ")
+        + PrintToString(ExportedType{moduleId, name, Storage::Version{majorVersion, minorVersion}}))
 {
-    const Storage::Synchronization::ExportedType &type = arg;
+    const ExportedType &type = arg;
 
     return type.moduleId == moduleId && type.name == name
            && type.version == Storage::Version{majorVersion, minorVersion};
@@ -106,10 +112,9 @@ MATCHER_P4(IsDirectoryInfo,
            moduleId,
            fileType,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(
-                   Storage::Synchronization::DirectoryInfo{directoryId, sourceId, moduleId, fileType}))
+               + PrintToString(DirectoryInfo{directoryId, sourceId, moduleId, fileType}))
 {
-    const Storage::Synchronization::DirectoryInfo &directoryInfo = arg;
+    const DirectoryInfo &directoryInfo = arg;
 
     return compareInvalidAreTrue(directoryInfo.directoryId, directoryId)
            && directoryInfo.sourceId == sourceId
@@ -119,7 +124,7 @@ MATCHER_P4(IsDirectoryInfo,
 
 MATCHER(PackageIsEmpty, std::string(negation ? "isn't empty" : "is empty"))
 {
-    const Storage::Synchronization::SynchronizationPackage &package = arg;
+    const SynchronizationPackage &package = arg;
 
     return package.imports.empty() && package.types.empty() && package.fileStatuses.empty()
            && package.updatedSourceIds.empty() && package.directoryInfos.empty()
@@ -138,11 +143,13 @@ auto IsPropertyEditorQmlPath(const ModuleIdMatcher &moduleIdMatcher,
                              const SourceIdMatcher &pathIdMatcher,
                              const SourceContextIdMatcher &directoryIdMatcher)
 {
-    using QmlDesigner::Storage::Synchronization::PropertyEditorQmlPath;
-    return AllOf(Field(&PropertyEditorQmlPath::moduleId, moduleIdMatcher),
-                 Field(&PropertyEditorQmlPath::typeName, typeNameMatcher),
-                 Field(&PropertyEditorQmlPath::pathId, pathIdMatcher),
-                 Field(&PropertyEditorQmlPath::directoryId, directoryIdMatcher));
+    return AllOf(
+        Field("PropertyEditorQmlPath::moduleId", &PropertyEditorQmlPath::moduleId, moduleIdMatcher),
+        Field("PropertyEditorQmlPath::typeName", &PropertyEditorQmlPath::typeName, typeNameMatcher),
+        Field("PropertyEditorQmlPath::pathId", &PropertyEditorQmlPath::pathId, pathIdMatcher),
+        Field("PropertyEditorQmlPath::directoryId",
+              &PropertyEditorQmlPath::directoryId,
+              directoryIdMatcher));
 }
 
 class ProjectStorageUpdater : public testing::Test
@@ -192,11 +199,11 @@ public:
             return storage.moduleId(name, kind);
         });
 
-        firstType.prototype = Storage::Synchronization::ImportedType{"Object"};
+        firstType.prototype = ImportedType{"Object"};
         firstType.traits = TypeTraitsKind::Reference;
-        secondType.prototype = Storage::Synchronization::ImportedType{"Object2"};
+        secondType.prototype = ImportedType{"Object2"};
         secondType.traits = TypeTraitsKind::Reference;
-        thirdType.prototype = Storage::Synchronization::ImportedType{"Object3"};
+        thirdType.prototype = ImportedType{"Object3"};
         thirdType.traits = TypeTraitsKind::Reference;
 
         setContent(u"/path/First.qml", qmlDocument1);
@@ -292,8 +299,7 @@ public:
         ON_CALL(fileSystemMock, qmlFileNames(Eq(directoryPath))).WillByDefault(Return(qmlFileNames));
     }
 
-    void setDirectoryInfos(SourceContextId directorySourceId,
-                           const QmlDesigner::Storage::Synchronization::DirectoryInfos &directoryInfos)
+    void setDirectoryInfos(SourceContextId directorySourceId, const DirectoryInfos &directoryInfos)
     {
         ON_CALL(projectStorageMock, fetchDirectoryInfos(Eq(directorySourceId)))
             .WillByDefault(Return(directoryInfos));
@@ -393,27 +399,24 @@ protected:
     ModuleId quickCppNativeModuleId{storage.moduleId("Quick", ModuleKind::CppLibrary)};
     ModuleId pathModuleId{storage.moduleId("/path", ModuleKind::PathLibrary)};
     ModuleId subPathQmlModuleId{storage.moduleId("/path/qml", ModuleKind::PathLibrary)};
-    Storage::Synchronization::Type objectType{
-        "QObject",
-        Storage::Synchronization::ImportedType{},
-        Storage::Synchronization::ImportedType{},
-        Storage::TypeTraitsKind::Reference,
-        qmltypesPathSourceId,
-        {Storage::Synchronization::ExportedType{exampleModuleId, "Object"},
-         Storage::Synchronization::ExportedType{exampleModuleId, "Obj"}}};
-    Storage::Synchronization::Type itemType{"QItem",
-                                            Storage::Synchronization::ImportedType{},
-                                            Storage::Synchronization::ImportedType{},
-                                            Storage::TypeTraitsKind::Reference,
-                                            qmltypes2PathSourceId,
-                                            {Storage::Synchronization::ExportedType{exampleModuleId,
-                                                                                    "Item"}}};
+    Type objectType{"QObject",
+                    ImportedType{},
+                    ImportedType{},
+                    Storage::TypeTraitsKind::Reference,
+                    qmltypesPathSourceId,
+                    {ExportedType{exampleModuleId, "Object"}, ExportedType{exampleModuleId, "Obj"}}};
+    Type itemType{"QItem",
+                  ImportedType{},
+                  ImportedType{},
+                  Storage::TypeTraitsKind::Reference,
+                  qmltypes2PathSourceId,
+                  {ExportedType{exampleModuleId, "Item"}}};
     QString qmlDocument1{"First{}"};
     QString qmlDocument2{"Second{}"};
     QString qmlDocument3{"Third{}"};
-    Storage::Synchronization::Type firstType;
-    Storage::Synchronization::Type secondType;
-    Storage::Synchronization::Type thirdType;
+    Type firstType;
+    Type secondType;
+    Type thirdType;
     Storage::Import import1{qmlModuleId, Storage::Version{2, 3}, qmlDocumentSourceId1};
     Storage::Import import2{qmlModuleId, Storage::Version{}, qmlDocumentSourceId2};
     Storage::Import import3{qmlModuleId, Storage::Version{2}, qmlDocumentSourceId3};
@@ -549,9 +552,19 @@ TEST_F(ProjectStorageUpdater, parse_qml_types)
     setContent(u"/path/example2.qmltypes", qmltypes2);
 
     EXPECT_CALL(qmlTypesParserMock,
-                parse(qmltypes, _, _, Field(&DirectoryInfo::moduleId, exampleCppNativeModuleId)));
+                parse(qmltypes,
+                      _,
+                      _,
+                      Field("DirectoryInfo::moduleId",
+                            &DirectoryInfo::moduleId,
+                            exampleCppNativeModuleId)));
     EXPECT_CALL(qmlTypesParserMock,
-                parse(qmltypes2, _, _, Field(&DirectoryInfo::moduleId, exampleCppNativeModuleId)));
+                parse(qmltypes2,
+                      _,
+                      _,
+                      Field("DirectoryInfo::moduleId",
+                            &DirectoryInfo::moduleId,
+                            exampleCppNativeModuleId)));
 
     updater.update({.directories = directories});
 }
@@ -570,9 +583,19 @@ TEST_F(ProjectStorageUpdater, parse_qml_types_in_subdirectories)
     setSubdirectoryPaths(u"/root", {"/path"});
 
     EXPECT_CALL(qmlTypesParserMock,
-                parse(qmltypes, _, _, Field(&DirectoryInfo::moduleId, exampleCppNativeModuleId)));
+                parse(qmltypes,
+                      _,
+                      _,
+                      Field("DirectoryInfo::moduleId",
+                            &DirectoryInfo::moduleId,
+                            exampleCppNativeModuleId)));
     EXPECT_CALL(qmlTypesParserMock,
-                parse(qmltypes2, _, _, Field(&DirectoryInfo::moduleId, exampleCppNativeModuleId)));
+                parse(qmltypes2,
+                      _,
+                      _,
+                      Field("DirectoryInfo::moduleId",
+                            &DirectoryInfo::moduleId,
+                            exampleCppNativeModuleId)));
 
     updater.update({.directories = directories});
 }
@@ -620,19 +643,27 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_types)
     EXPECT_CALL(projectStorageMock, moduleId(Eq("/path"), ModuleKind::PathLibrary));
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::imports, ElementsAre(import)),
-                          Field(&SynchronizationPackage::types, ElementsAre(Eq(objectType))),
-                          Field(&SynchronizationPackage::updatedSourceIds,
+                    AllOf(Field("SynchronizationPackage::imports",
+                                &SynchronizationPackage::imports,
+                                ElementsAre(import)),
+                          Field("SynchronizationPackage::types",
+                                &SynchronizationPackage::types,
+                                ElementsAre(Eq(objectType))),
+                          Field("SynchronizationPackage::updatedSourceIds",
+                                &SynchronizationPackage::updatedSourceIds,
                                 UnorderedElementsAre(qmlDirPathSourceId, qmltypesPathSourceId)),
-                          Field(&SynchronizationPackage::fileStatuses,
+                          Field("SynchronizationPackage::fileStatuses",
+                                &SynchronizationPackage::fileStatuses,
                                 UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                                      IsFileStatus(qmltypesPathSourceId, 1, 21))),
-                          Field(&SynchronizationPackage::directoryInfos,
+                          Field("SynchronizationPackage::directoryInfos",
+                                &SynchronizationPackage::directoryInfos,
                                 UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                                      qmltypesPathSourceId,
                                                                      exampleCppNativeModuleId,
                                                                      FileType::QmlTypes))),
-                          Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                          Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                                &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                                 UnorderedElementsAre(directoryPathId)))));
 
     updater.update({.directories = directories});
@@ -651,12 +682,14 @@ TEST_F(ProjectStorageUpdater, synchronize_subdircectories)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(rootDirectoryPathId, path1SourceId, ModuleId{}, FileType::Directory),
                       IsDirectoryInfo(rootDirectoryPathId, path2SourceId, ModuleId{}, FileType::Directory),
                       IsDirectoryInfo(path1SourceContextId, path3SourceId, ModuleId{}, FileType::Directory))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(rootDirectoryPathId,
                                        path1SourceContextId,
                                        path2SourceContextId,
@@ -675,12 +708,14 @@ TEST_F(ProjectStorageUpdater, synchronize_subdircectories_even_for_no_changes)
     setFilesDontChanged({rootDirectoryPathSourceId});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::directoryInfos,
+                synchronize(AllOf(Field("SynchronizationPackage::directoryInfos",
+                                        &SynchronizationPackage::directoryInfos,
                                         UnorderedElementsAre(IsDirectoryInfo(path1SourceContextId,
                                                                              path3SourceId,
                                                                              ModuleId{},
                                                                              FileType::Directory))),
-                                  Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                                  Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                                        &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                                         UnorderedElementsAre(path1SourceContextId,
                                                              path2SourceContextId,
                                                              path3SourceContextId)))));
@@ -704,12 +739,14 @@ TEST_F(ProjectStorageUpdater, synchronize_subdircectories_for_deleted_subdirecti
     setSubdirectorySourceIds(path1SourceContextId, {path3SourceContextId});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::directoryInfos,
+                synchronize(AllOf(Field("SynchronizationPackage::directoryInfos",
+                                        &SynchronizationPackage::directoryInfos,
                                         UnorderedElementsAre(IsDirectoryInfo(rootDirectoryPathId,
                                                                              path2SourceId,
                                                                              ModuleId{},
                                                                              FileType::Directory))),
-                                  Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                                  Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                                        &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                                         UnorderedElementsAre(rootDirectoryPathId,
                                                              path1SourceContextId,
                                                              path2SourceContextId,
@@ -814,52 +851,62 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -882,53 +929,63 @@ TEST_F(ProjectStorageUpdater, skip_duplicate_qmldir_entries)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(exampleModuleId, "FirstType", 2, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -951,45 +1008,55 @@ TEST_F(ProjectStorageUpdater, synchronize_add_only_qml_document_in_directory)
     setQmlFileNames(u"/path", {"First.qml", "First2.qml"});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(
-                    Field(&SynchronizationPackage::imports, UnorderedElementsAre(import2)),
-                    Field(&SynchronizationPackage::types,
-                          UnorderedElementsAre(
-                              AllOf(IsStorageType("First.qml",
-                                                  Storage::Synchronization::ImportedType{},
-                                                  TypeTraitsKind::None,
-                                                  qmlDocumentSourceId1,
-                                                  Storage::Synchronization::ChangeLevel::Minimal),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(exampleModuleId, "FirstType", 1, 0),
-                                              IsExportedType(pathModuleId, "First", -1, -1)))),
-                              AllOf(IsStorageType("First2.qml",
-                                                  Storage::Synchronization::ImportedType{"Object2"},
-                                                  TypeTraitsKind::Reference,
-                                                  qmlDocumentSourceId2,
-                                                  Storage::Synchronization::ChangeLevel::Full),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(pathModuleId, "First2", -1, -1)))))),
-                    Field(&SynchronizationPackage::updatedSourceIds,
-                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-                    Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                          UnorderedElementsAre(directoryPathSourceId, qmlDocumentSourceId2)),
-                    Field(&SynchronizationPackage::fileStatuses,
-                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId2, 1, 21),
-                                               IsFileStatus(directoryPathSourceId, 1, 21))),
-                    Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                          UnorderedElementsAre(directoryPathId)),
-                    Field(&SynchronizationPackage::directoryInfos,
-                          UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId1,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument),
-                                               IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId2,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument))))));
+                synchronize(
+                    AllOf(Field("SynchronizationPackage::imports",
+                                &SynchronizationPackage::imports,
+                                UnorderedElementsAre(import2)),
+                          Field("SynchronizationPackage::types",
+                                &SynchronizationPackage::types,
+                                UnorderedElementsAre(
+                                    AllOf(IsStorageType("First.qml",
+                                                        ImportedType{},
+                                                        TypeTraitsKind::None,
+                                                        qmlDocumentSourceId1,
+                                                        ChangeLevel::Minimal),
+                                          Field("Type::exportedTypes",
+                                                &Type::exportedTypes,
+                                                UnorderedElementsAre(
+                                                    IsExportedType(exampleModuleId, "FirstType", 1, 0),
+                                                    IsExportedType(pathModuleId, "First", -1, -1)))),
+                                    AllOf(IsStorageType("First2.qml",
+                                                        ImportedType{"Object2"},
+                                                        TypeTraitsKind::Reference,
+                                                        qmlDocumentSourceId2,
+                                                        ChangeLevel::Full),
+                                          Field("Type::exportedTypes",
+                                                &Type::exportedTypes,
+                                                UnorderedElementsAre(
+                                                    IsExportedType(pathModuleId, "First2", -1, -1)))))),
+                          Field("SynchronizationPackage::updatedSourceIds",
+                                &SynchronizationPackage::updatedSourceIds,
+                                UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                          Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                                &SynchronizationPackage::updatedFileStatusSourceIds,
+                                UnorderedElementsAre(directoryPathSourceId, qmlDocumentSourceId2)),
+                          Field("SynchronizationPackage::fileStatuses",
+                                &SynchronizationPackage::fileStatuses,
+                                UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId2, 1, 21),
+                                                     IsFileStatus(directoryPathSourceId, 1, 21))),
+                          Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                                &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                                UnorderedElementsAre(directoryPathId)),
+                          Field("SynchronizationPackage::directoryInfos",
+                                &SynchronizationPackage::directoryInfos,
+                                UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
+                                                                     qmlDocumentSourceId1,
+                                                                     ModuleId{},
+                                                                     FileType::QmlDocument),
+                                                     IsDirectoryInfo(directoryPathId,
+                                                                     qmlDocumentSourceId2,
+                                                                     ModuleId{},
+                                                                     FileType::QmlDocument))))));
 
     updater.update({.directories = directories});
 }
@@ -1010,49 +1077,57 @@ TEST_F(ProjectStorageUpdater, synchronize_removes_qml_document)
                        {directoryPathId, qmlDocumentSourceId3, ModuleId{}, FileType::QmlDocument}});
     setQmlFileNames(u"/path", {"First.qml", "First2.qml"});
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(
-                    Field(&SynchronizationPackage::imports, IsEmpty()),
-                    Field(&SynchronizationPackage::types,
-                          UnorderedElementsAre(
-                              AllOf(IsStorageType("First.qml",
-                                                  Storage::Synchronization::ImportedType{},
-                                                  TypeTraitsKind::None,
-                                                  qmlDocumentSourceId1,
-                                                  Storage::Synchronization::ChangeLevel::Minimal),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(exampleModuleId, "FirstType", 1, 0),
-                                              IsExportedType(pathModuleId, "First", -1, -1)))),
-                              AllOf(IsStorageType("First2.qml",
-                                                  Storage::Synchronization::ImportedType{},
-                                                  TypeTraitsKind::None,
-                                                  qmlDocumentSourceId2,
-                                                  Storage::Synchronization::ChangeLevel::Minimal),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(exampleModuleId, "FirstType", 2, 2),
-                                              IsExportedType(pathModuleId, "First2", -1, -1)))))),
-                    Field(&SynchronizationPackage::updatedSourceIds,
-                          UnorderedElementsAre(qmlDirPathSourceId,
-                                               qmlDocumentSourceId1,
-                                               qmlDocumentSourceId2,
-                                               qmlDocumentSourceId3)),
-                    Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                          UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
-                    Field(&SynchronizationPackage::fileStatuses,
-                          UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-                    Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                          UnorderedElementsAre(directoryPathId)),
-                    Field(&SynchronizationPackage::directoryInfos,
-                          UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId1,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument),
-                                               IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId2,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument))))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(AllOf(
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field(
+                "SynchronizationPackage::types",
+                &SynchronizationPackage::types,
+                UnorderedElementsAre(
+                    AllOf(IsStorageType("First.qml",
+                                        ImportedType{},
+                                        TypeTraitsKind::None,
+                                        qmlDocumentSourceId1,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
+                                                     IsExportedType(pathModuleId, "First", -1, -1)))),
+                    AllOf(IsStorageType("First2.qml",
+                                        ImportedType{},
+                                        TypeTraitsKind::None,
+                                        qmlDocumentSourceId2,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
+                                                     IsExportedType(pathModuleId, "First2", -1, -1)))))),
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
+                  UnorderedElementsAre(qmlDirPathSourceId,
+                                       qmlDocumentSourceId1,
+                                       qmlDocumentSourceId2,
+                                       qmlDocumentSourceId3)),
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
+                  UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
+                  UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                  UnorderedElementsAre(directoryPathId)),
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
+                  UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
+                                                       qmlDocumentSourceId1,
+                                                       ModuleId{},
+                                                       FileType::QmlDocument),
+                                       IsDirectoryInfo(directoryPathId,
+                                                       qmlDocumentSourceId2,
+                                                       ModuleId{},
+                                                       FileType::QmlDocument))))));
 
     updater.update({.directories = directories});
 }
@@ -1073,33 +1148,41 @@ TEST_F(ProjectStorageUpdater, synchronize_removes_qml_document_in_qmldir_only)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(
                       AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                        IsExportedType(pathModuleId, "First", -1, -1)))),
                       AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "First2", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -1129,35 +1212,42 @@ TEST_F(ProjectStorageUpdater, synchronize_add_qml_document_to_qmldir)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -1186,33 +1276,41 @@ TEST_F(ProjectStorageUpdater, synchronize_remove_qml_document_from_qmldir)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(
                       AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                        IsExportedType(pathModuleId, "First", -1, -1)))),
                       AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "First2", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -1237,48 +1335,58 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_dont_update_if_up_to_dat
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -1297,43 +1405,49 @@ TEST_F(ProjectStorageUpdater, synchroniz_if_qmldir_file_has_not_changed)
                        {directoryPathId, qmlDocumentSourceId2, exampleModuleId, FileType::QmlDocument}});
     setFilesDontChanged({qmlDirPathSourceId});
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports,
-                  UnorderedElementsAre(import1, import2, import4, import5)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      Eq(objectType),
-                      Eq(itemType),
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmltypesPathSourceId,
-                                       qmltypes2PathSourceId,
-                                       qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
-                                       IsFileStatus(qmltypes2PathSourceId, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmltypesPathSourceId,
-                                       qmltypes2PathSourceId,
-                                       qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2, import4, import5)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              Eq(objectType),
+                              Eq(itemType),
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmltypesPathSourceId,
+                                               qmltypes2PathSourceId,
+                                               qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
+                                               IsFileStatus(qmltypes2PathSourceId, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmltypesPathSourceId,
+                                               qmltypes2PathSourceId,
+                                               qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.update({.directories = directories});
 }
@@ -1347,27 +1461,34 @@ TEST_F(ProjectStorageUpdater, synchroniz_if_qmldir_file_has_not_changed_and_some
                        {directoryPathId, qmlDocumentSourceId2, exampleModuleId, FileType::QmlDocument}});
     setFilesDontChanged({qmlDirPathSourceId, qmltypes2PathSourceId, qmlDocumentSourceId2});
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(
-            AllOf(Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import4)),
-                  Field(&SynchronizationPackage::types,
-                        UnorderedElementsAre(
-                            Eq(objectType),
-                            AllOf(IsStorageType("First.qml",
-                                                Storage::Synchronization::ImportedType{"Object"},
-                                                TypeTraitsKind::Reference,
-                                                qmlDocumentSourceId1,
-                                                Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                                  Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-                  Field(&SynchronizationPackage::updatedSourceIds,
-                        UnorderedElementsAre(qmltypesPathSourceId, qmlDocumentSourceId1)),
-                  Field(&SynchronizationPackage::fileStatuses,
-                        UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
-                                             IsFileStatus(qmlDocumentSourceId1, 1, 21))),
-                  Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                        UnorderedElementsAre(qmltypesPathSourceId, qmlDocumentSourceId1)),
-                  Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import4)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              Eq(objectType),
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmltypesPathSourceId, qmlDocumentSourceId1)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId1, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmltypesPathSourceId, qmlDocumentSourceId1)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.update({.directories = directories});
 }
@@ -1404,27 +1525,33 @@ TEST_F(ProjectStorageUpdater, synchroniz_if_qmldir_file_has_changed_and_some_rem
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(AllOf(
                       IsStorageType("First2.qml",
-                                    Storage::Synchronization::ImportedType{},
+                                    ImportedType{},
                                     TypeTraitsKind::None,
                                     qmlDocumentSourceId2,
-                                    Storage::Synchronization::ChangeLevel::Minimal),
-                      Field(&Storage::Synchronization::Type::exportedTypes,
+                                    ChangeLevel::Minimal),
+                      Field("Type::exportedTypes",
+                            &Type::exportedTypes,
                             UnorderedElementsAre(IsExportedType(pathModuleId, "First2", -1, -1),
                                                  IsExportedType(exampleModuleId, "FirstType", 2, 2)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmltypesPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmltypesPathSourceId, qmlDocumentSourceId1)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId2,
                                                        ModuleId{},
@@ -1439,15 +1566,26 @@ TEST_F(ProjectStorageUpdater, synchroniz_if_qmldir_file_has_changed_and_some_rem
 
 TEST_F(ProjectStorageUpdater, update_qml_types_files_is_empty)
 {
-    EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::imports, IsEmpty()),
-                                  Field(&SynchronizationPackage::types, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedSourceIds, IsEmpty()),
-                                  Field(&SynchronizationPackage::fileStatuses, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedFileStatusSourceIds, IsEmpty()),
-                                  Field(&SynchronizationPackage::directoryInfos, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                                        IsEmpty()))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(
+            AllOf(Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+                  Field("SynchronizationPackage::types", &SynchronizationPackage::types, IsEmpty()),
+                  Field("SynchronizationPackage::updatedSourceIds",
+                        &SynchronizationPackage::updatedSourceIds,
+                        IsEmpty()),
+                  Field("SynchronizationPackage::fileStatuses",
+                        &SynchronizationPackage::fileStatuses,
+                        IsEmpty()),
+                  Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                        &SynchronizationPackage::updatedFileStatusSourceIds,
+                        IsEmpty()),
+                  Field("SynchronizationPackage::directoryInfos",
+                        &SynchronizationPackage::directoryInfos,
+                        IsEmpty()),
+                  Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                        &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                        IsEmpty()))));
 
     updater.update({});
 }
@@ -1464,29 +1602,38 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_with_different_version_b
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1)),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1)),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(AllOf(
                       IsStorageType("First.qml",
-                                    Storage::Synchronization::ImportedType{"Object"},
+                                    ImportedType{"Object"},
                                     TypeTraitsKind::Reference,
                                     qmlDocumentSourceId1,
-                                    Storage::Synchronization::ChangeLevel::Full),
-                      Field(&Storage::Synchronization::Type::exportedTypes,
+                                    ChangeLevel::Full),
+                      Field("Type::exportedTypes",
+                            &Type::exportedTypes,
                             UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                  IsExportedType(exampleModuleId, "FirstType", 1, 1),
                                                  IsExportedType(exampleModuleId, "FirstType", 6, 0),
                                                  IsExportedType(pathModuleId, "First", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(
                       directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument))))));
 
@@ -1504,28 +1651,37 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_with_different_type_name
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1)),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1)),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(AllOf(
                       IsStorageType("First.qml",
-                                    Storage::Synchronization::ImportedType{"Object"},
+                                    ImportedType{"Object"},
                                     TypeTraitsKind::Reference,
                                     qmlDocumentSourceId1,
-                                    Storage::Synchronization::ChangeLevel::Full),
-                      Field(&Storage::Synchronization::Type::exportedTypes,
+                                    ChangeLevel::Full),
+                      Field("Type::exportedTypes",
+                            &Type::exportedTypes,
                             UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                  IsExportedType(exampleModuleId, "FirstType2", 1, 0),
                                                  IsExportedType(pathModuleId, "First", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(
                       directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument))))));
 
@@ -1544,7 +1700,8 @@ TEST_F(ProjectStorageUpdater, dont_synchronize_selectors)
     EXPECT_CALL(projectStorageMock,
                 synchronize(Not(Field(
                     &SynchronizationPackage::types,
-                    Contains(Field(&Storage::Synchronization::Type::exportedTypes,
+                    Contains(Field("Type::exportedTypes",
+                                   &Type::exportedTypes,
                                    Contains(IsExportedType(exampleModuleId, "FirstType", 1, 0))))))));
 
     updater.update({.directories = directories});
@@ -1563,13 +1720,15 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_dependencies)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::moduleDependencies,
+            Field("SynchronizationPackage::moduleDependencies",
+                  &SynchronizationPackage::moduleDependencies,
                   UnorderedElementsAre(
                       Import{qmlCppNativeModuleId, Storage::Version{}, qmltypesPathSourceId},
                       Import{builtinCppNativeModuleId, Storage::Version{}, qmltypesPathSourceId},
                       Import{qmlCppNativeModuleId, Storage::Version{}, qmltypes2PathSourceId},
                       Import{builtinCppNativeModuleId, Storage::Version{}, qmltypes2PathSourceId})),
-            Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
+            Field("SynchronizationPackage::updatedModuleDependencySourceIds",
+                  &SynchronizationPackage::updatedModuleDependencySourceIds,
                   UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
 
     updater.update({.directories = directories});
@@ -1589,13 +1748,15 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_dependencies_with_double_entrie
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::moduleDependencies,
+            Field("SynchronizationPackage::moduleDependencies",
+                  &SynchronizationPackage::moduleDependencies,
                   UnorderedElementsAre(
                       Import{qmlCppNativeModuleId, Storage::Version{}, qmltypesPathSourceId},
                       Import{builtinCppNativeModuleId, Storage::Version{}, qmltypesPathSourceId},
                       Import{qmlCppNativeModuleId, Storage::Version{}, qmltypes2PathSourceId},
                       Import{builtinCppNativeModuleId, Storage::Version{}, qmltypes2PathSourceId})),
-            Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
+            Field("SynchronizationPackage::updatedModuleDependencySourceIds",
+                  &SynchronizationPackage::updatedModuleDependencySourceIds,
                   UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
 
     updater.update({.directories = directories});
@@ -1615,13 +1776,15 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_dependencies_with_colliding_imp
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::moduleDependencies,
+            Field("SynchronizationPackage::moduleDependencies",
+                  &SynchronizationPackage::moduleDependencies,
                   UnorderedElementsAre(
                       Import{qmlCppNativeModuleId, Storage::Version{}, qmltypesPathSourceId},
                       Import{builtinCppNativeModuleId, Storage::Version{}, qmltypesPathSourceId},
                       Import{qmlCppNativeModuleId, Storage::Version{}, qmltypes2PathSourceId},
                       Import{builtinCppNativeModuleId, Storage::Version{}, qmltypes2PathSourceId})),
-            Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
+            Field("SynchronizationPackage::updatedModuleDependencySourceIds",
+                  &SynchronizationPackage::updatedModuleDependencySourceIds,
                   UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
 
     updater.update({.directories = directories});
@@ -1637,8 +1800,11 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_with_no_dependencies)
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::moduleDependencies, IsEmpty()),
-                          Field(&SynchronizationPackage::updatedModuleDependencySourceIds,
+                    AllOf(Field("SynchronizationPackage::moduleDependencies",
+                                &SynchronizationPackage::moduleDependencies,
+                                IsEmpty()),
+                          Field("SynchronizationPackage::updatedModuleDependencySourceIds",
+                                &SynchronizationPackage::updatedModuleDependencySourceIds,
                                 UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)))));
 
     updater.update({.directories = directories});
@@ -1655,7 +1821,8 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_imports)
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::moduleExportedImports,
+                    AllOf(Field("SynchronizationPackage::moduleExportedImports",
+                                &SynchronizationPackage::moduleExportedImports,
                                 UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                                           qmlModuleId,
                                                                           Storage::Version{},
@@ -1680,7 +1847,8 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_imports)
                                                                           quickCppNativeModuleId,
                                                                           Storage::Version{},
                                                                           IsAutoVersion::No})),
-                          Field(&SynchronizationPackage::updatedModuleIds,
+                          Field("SynchronizationPackage::updatedModuleIds",
+                                &SynchronizationPackage::updatedModuleIds,
                                 ElementsAre(exampleModuleId)))));
 
     updater.update({.directories = directories});
@@ -1693,8 +1861,11 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_with_no_imports)
     setContent(u"/path/qmldir", qmldir);
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::moduleExportedImports, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedModuleIds,
+                synchronize(AllOf(Field("SynchronizationPackage::moduleExportedImports",
+                                        &SynchronizationPackage::moduleExportedImports,
+                                        IsEmpty()),
+                                  Field("SynchronizationPackage::updatedModuleIds",
+                                        &SynchronizationPackage::updatedModuleIds,
                                         ElementsAre(exampleModuleId)))));
 
     updater.update({.directories = directories});
@@ -1712,7 +1883,8 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_imports_with_double_entries)
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::moduleExportedImports,
+                    AllOf(Field("SynchronizationPackage::moduleExportedImports",
+                                &SynchronizationPackage::moduleExportedImports,
                                 UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                                           qmlModuleId,
                                                                           Storage::Version{},
@@ -1737,7 +1909,8 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_imports_with_double_entries)
                                                                           quickCppNativeModuleId,
                                                                           Storage::Version{},
                                                                           IsAutoVersion::No})),
-                          Field(&SynchronizationPackage::updatedModuleIds,
+                          Field("SynchronizationPackage::updatedModuleIds",
+                                &SynchronizationPackage::updatedModuleIds,
                                 ElementsAre(exampleModuleId)))));
 
     updater.update({.directories = directories});
@@ -1754,7 +1927,8 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_default_imports)
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::moduleExportedImports,
+                    AllOf(Field("SynchronizationPackage::moduleExportedImports",
+                                &SynchronizationPackage::moduleExportedImports,
                                 UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                                           qmlModuleId,
                                                                           Storage::Version{},
@@ -1779,7 +1953,8 @@ TEST_F(ProjectStorageUpdater, synchronize_qmldir_default_imports)
                                                                           quickCppNativeModuleId,
                                                                           Storage::Version{},
                                                                           IsAutoVersion::No})),
-                          Field(&SynchronizationPackage::updatedModuleIds,
+                          Field("SynchronizationPackage::updatedModuleIds",
+                                &SynchronizationPackage::updatedModuleIds,
                                 ElementsAre(exampleModuleId)))));
 
     updater.update({.directories = directories});
@@ -1796,7 +1971,8 @@ TEST_F(ProjectStorageUpdater, do_not_synchronize_qmldir_optional_imports)
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::moduleExportedImports,
+                    AllOf(Field("SynchronizationPackage::moduleExportedImports",
+                                &SynchronizationPackage::moduleExportedImports,
                                 UnorderedElementsAre(ModuleExportedImport{exampleModuleId,
                                                                           qmlModuleId,
                                                                           Storage::Version{},
@@ -1813,7 +1989,8 @@ TEST_F(ProjectStorageUpdater, do_not_synchronize_qmldir_optional_imports)
                                                                           builtinCppNativeModuleId,
                                                                           Storage::Version{},
                                                                           IsAutoVersion::No})),
-                          Field(&SynchronizationPackage::updatedModuleIds,
+                          Field("SynchronizationPackage::updatedModuleIds",
+                                &SynchronizationPackage::updatedModuleIds,
                                 ElementsAre(exampleModuleId)))));
 
     updater.update({.directories = directories});
@@ -2068,49 +2245,60 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_without_qmldir)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(
                       AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
+                                          ImportedType{"Object"},
                                           TypeTraitsKind::Reference,
                                           qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::Full),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Full),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "First", -1, -1)))),
                       AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
+                                          ImportedType{"Object2"},
                                           TypeTraitsKind::Reference,
                                           qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::Full),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Full),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "First2", -1, -1)))),
                       AllOf(IsStorageType("Second.qml",
-                                          Storage::Synchronization::ImportedType{"Object3"},
+                                          ImportedType{"Object3"},
                                           TypeTraitsKind::Reference,
                                           qmlDocumentSourceId3,
-                                          Storage::Synchronization::ChangeLevel::Full),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Full),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(directoryPathSourceId,
                                        qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -2153,40 +2341,50 @@ TEST_F(ProjectStorageUpdater,
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import2)),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import2)),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(
                       AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::Full),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Full),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(
                                       IsExportedType(exampleModuleId, "FirstType", 1, 0)))),
                       AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
+                                          ImportedType{"Object2"},
                                           TypeTraitsKind::Reference,
                                           qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::Full),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Full),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(
                                       IsExportedType(pathModuleId, "First2", -1, -1),
                                       IsExportedType(exampleModuleId, "FirstType", 2, 2)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(directoryPathSourceId,
                                        qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21),
                                        IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -2207,24 +2405,33 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_without_qmldir_throws_if
                        {directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument},
                        {directoryPathId, qmlDocumentSourceId3, ModuleId{}, FileType::QmlDocument}});
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::imports, IsEmpty()),
-                                  Field(&SynchronizationPackage::types, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedSourceIds,
-                                        UnorderedElementsAre(qmlDirPathSourceId,
-                                                             qmlDocumentSourceId1,
-                                                             qmlDocumentSourceId2,
-                                                             qmlDocumentSourceId3)),
-                                  Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                                        UnorderedElementsAre(directoryPathSourceId,
-                                                             qmlDirPathSourceId,
-                                                             qmlDocumentSourceId1,
-                                                             qmlDocumentSourceId2,
-                                                             qmlDocumentSourceId3)),
-                                  Field(&SynchronizationPackage::fileStatuses, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                                        UnorderedElementsAre(directoryPathId)),
-                                  Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(
+            AllOf(Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+                  Field("SynchronizationPackage::types", &SynchronizationPackage::types, IsEmpty()),
+                  Field("SynchronizationPackage::updatedSourceIds",
+                        &SynchronizationPackage::updatedSourceIds,
+                        UnorderedElementsAre(qmlDirPathSourceId,
+                                             qmlDocumentSourceId1,
+                                             qmlDocumentSourceId2,
+                                             qmlDocumentSourceId3)),
+                  Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                        &SynchronizationPackage::updatedFileStatusSourceIds,
+                        UnorderedElementsAre(directoryPathSourceId,
+                                             qmlDirPathSourceId,
+                                             qmlDocumentSourceId1,
+                                             qmlDocumentSourceId2,
+                                             qmlDocumentSourceId3)),
+                  Field("SynchronizationPackage::fileStatuses",
+                        &SynchronizationPackage::fileStatuses,
+                        IsEmpty()),
+                  Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                        &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                        UnorderedElementsAre(directoryPathId)),
+                  Field("SynchronizationPackage::directoryInfos",
+                        &SynchronizationPackage::directoryInfos,
+                        IsEmpty()))));
 
     updater.update({.directories = directories});
 }
@@ -2242,26 +2449,35 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_without_qmldir_add_qml_d
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import3)),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import3)),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(AllOf(
                       IsStorageType("Second.qml",
-                                    Storage::Synchronization::ImportedType{"Object3"},
+                                    ImportedType{"Object3"},
                                     TypeTraitsKind::Reference,
                                     qmlDocumentSourceId3,
-                                    Storage::Synchronization::ChangeLevel::Full),
-                      Field(&Storage::Synchronization::Type::exportedTypes,
+                                    ChangeLevel::Full),
+                      Field("Type::exportedTypes",
+                            &Type::exportedTypes,
                             UnorderedElementsAre(IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(directoryPathSourceId, qmlDirPathSourceId, qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -2283,29 +2499,33 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_documents_without_qmldir_removes_q
                        {directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument},
                        {directoryPathId, qmlDocumentSourceId3, ModuleId{}, FileType::QmlDocument}});
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(
-                    AllOf(Field(&SynchronizationPackage::imports, IsEmpty()),
-                          Field(&SynchronizationPackage::types, IsEmpty()),
-                          Field(&SynchronizationPackage::updatedSourceIds,
-                                UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
-                          Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                                UnorderedElementsAre(directoryPathSourceId,
-                                                     qmlDirPathSourceId,
-                                                     qmlDocumentSourceId3)),
-                          Field(&SynchronizationPackage::fileStatuses,
-                                UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21))),
-                          Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                                UnorderedElementsAre(directoryPathId)),
-                          Field(&SynchronizationPackage::directoryInfos,
-                                UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
-                                                                     qmlDocumentSourceId1,
-                                                                     ModuleId{},
-                                                                     FileType::QmlDocument),
-                                                     IsDirectoryInfo(directoryPathId,
-                                                                     qmlDocumentSourceId2,
-                                                                     ModuleId{},
-                                                                     FileType::QmlDocument))))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(AllOf(
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::types", &SynchronizationPackage::types, IsEmpty()),
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
+                  UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
+                  UnorderedElementsAre(directoryPathSourceId, qmlDirPathSourceId, qmlDocumentSourceId3)),
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
+                  UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21))),
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                  UnorderedElementsAre(directoryPathId)),
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
+                  UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
+                                                       qmlDocumentSourceId1,
+                                                       ModuleId{},
+                                                       FileType::QmlDocument),
+                                       IsDirectoryInfo(directoryPathId,
+                                                       qmlDocumentSourceId2,
+                                                       ModuleId{},
+                                                       FileType::QmlDocument))))));
 
     updater.update({.directories = directories});
 }
@@ -2323,49 +2543,59 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directories)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2, qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(directoryPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -2393,37 +2623,44 @@ TEST_F(ProjectStorageUpdater, watcher_updates_subdirectories)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2, qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -2445,24 +2682,33 @@ TEST_F(ProjectStorageUpdater, watcher_updates_removed_directory)
                        {directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument},
                        {directoryPathId, qmlDocumentSourceId3, ModuleId{}, FileType::QmlDocument}});
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::imports, IsEmpty()),
-                                  Field(&SynchronizationPackage::types, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedSourceIds,
-                                        UnorderedElementsAre(qmlDirPathSourceId,
-                                                             qmlDocumentSourceId1,
-                                                             qmlDocumentSourceId2,
-                                                             qmlDocumentSourceId3)),
-                                  Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                                        UnorderedElementsAre(directoryPathSourceId,
-                                                             qmlDirPathSourceId,
-                                                             qmlDocumentSourceId1,
-                                                             qmlDocumentSourceId2,
-                                                             qmlDocumentSourceId3)),
-                                  Field(&SynchronizationPackage::fileStatuses, UnorderedElementsAre()),
-                                  Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                                        UnorderedElementsAre(directoryPathId)),
-                                  Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(
+            AllOf(Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+                  Field("SynchronizationPackage::types", &SynchronizationPackage::types, IsEmpty()),
+                  Field("SynchronizationPackage::updatedSourceIds",
+                        &SynchronizationPackage::updatedSourceIds,
+                        UnorderedElementsAre(qmlDirPathSourceId,
+                                             qmlDocumentSourceId1,
+                                             qmlDocumentSourceId2,
+                                             qmlDocumentSourceId3)),
+                  Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                        &SynchronizationPackage::updatedFileStatusSourceIds,
+                        UnorderedElementsAre(directoryPathSourceId,
+                                             qmlDirPathSourceId,
+                                             qmlDocumentSourceId1,
+                                             qmlDocumentSourceId2,
+                                             qmlDocumentSourceId3)),
+                  Field("SynchronizationPackage::fileStatuses",
+                        &SynchronizationPackage::fileStatuses,
+                        UnorderedElementsAre()),
+                  Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                        &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                        UnorderedElementsAre(directoryPathId)),
+                  Field("SynchronizationPackage::directoryInfos",
+                        &SynchronizationPackage::directoryInfos,
+                        IsEmpty()))));
 
     updater.pathsWithIdsChanged({{directoryProjectChunkId, {directoryPathSourceId}}});
 }
@@ -2517,54 +2763,64 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directories_and_qmldir)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(directoryPathSourceId,
                                        qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21),
                                        IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -2624,45 +2880,55 @@ TEST_F(ProjectStorageUpdater, watcher_updates_add_only_qml_document_in_directory
     setQmlFileNames(u"/path", {"First.qml", "First2.qml"});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(
-                    Field(&SynchronizationPackage::imports, UnorderedElementsAre(import2)),
-                    Field(&SynchronizationPackage::types,
-                          UnorderedElementsAre(
-                              AllOf(IsStorageType("First.qml",
-                                                  Storage::Synchronization::ImportedType{},
-                                                  TypeTraitsKind::None,
-                                                  qmlDocumentSourceId1,
-                                                  Storage::Synchronization::ChangeLevel::Minimal),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(exampleModuleId, "FirstType", 1, 0),
-                                              IsExportedType(pathModuleId, "First", -1, -1)))),
-                              AllOf(IsStorageType("First2.qml",
-                                                  Storage::Synchronization::ImportedType{"Object2"},
-                                                  TypeTraitsKind::Reference,
-                                                  qmlDocumentSourceId2,
-                                                  Storage::Synchronization::ChangeLevel::Full),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(pathModuleId, "First2", -1, -1)))))),
-                    Field(&SynchronizationPackage::updatedSourceIds,
-                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-                    Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                          UnorderedElementsAre(directoryPathSourceId, qmlDocumentSourceId2)),
-                    Field(&SynchronizationPackage::fileStatuses,
-                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId2, 1, 21),
-                                               IsFileStatus(directoryPathSourceId, 1, 21))),
-                    Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                          UnorderedElementsAre(directoryPathId)),
-                    Field(&SynchronizationPackage::directoryInfos,
-                          UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId1,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument),
-                                               IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId2,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument))))));
+                synchronize(
+                    AllOf(Field("SynchronizationPackage::imports",
+                                &SynchronizationPackage::imports,
+                                UnorderedElementsAre(import2)),
+                          Field("SynchronizationPackage::types",
+                                &SynchronizationPackage::types,
+                                UnorderedElementsAre(
+                                    AllOf(IsStorageType("First.qml",
+                                                        ImportedType{},
+                                                        TypeTraitsKind::None,
+                                                        qmlDocumentSourceId1,
+                                                        ChangeLevel::Minimal),
+                                          Field("Type::exportedTypes",
+                                                &Type::exportedTypes,
+                                                UnorderedElementsAre(
+                                                    IsExportedType(exampleModuleId, "FirstType", 1, 0),
+                                                    IsExportedType(pathModuleId, "First", -1, -1)))),
+                                    AllOf(IsStorageType("First2.qml",
+                                                        ImportedType{"Object2"},
+                                                        TypeTraitsKind::Reference,
+                                                        qmlDocumentSourceId2,
+                                                        ChangeLevel::Full),
+                                          Field("Type::exportedTypes",
+                                                &Type::exportedTypes,
+                                                UnorderedElementsAre(
+                                                    IsExportedType(pathModuleId, "First2", -1, -1)))))),
+                          Field("SynchronizationPackage::updatedSourceIds",
+                                &SynchronizationPackage::updatedSourceIds,
+                                UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                          Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                                &SynchronizationPackage::updatedFileStatusSourceIds,
+                                UnorderedElementsAre(directoryPathSourceId, qmlDocumentSourceId2)),
+                          Field("SynchronizationPackage::fileStatuses",
+                                &SynchronizationPackage::fileStatuses,
+                                UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId2, 1, 21),
+                                                     IsFileStatus(directoryPathSourceId, 1, 21))),
+                          Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                                &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                                UnorderedElementsAre(directoryPathId)),
+                          Field("SynchronizationPackage::directoryInfos",
+                                &SynchronizationPackage::directoryInfos,
+                                UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
+                                                                     qmlDocumentSourceId1,
+                                                                     ModuleId{},
+                                                                     FileType::QmlDocument),
+                                                     IsDirectoryInfo(directoryPathId,
+                                                                     qmlDocumentSourceId2,
+                                                                     ModuleId{},
+                                                                     FileType::QmlDocument))))));
 
     updater.pathsWithIdsChanged({{directoryProjectChunkId, {directoryPathSourceId}}});
 }
@@ -2683,49 +2949,57 @@ TEST_F(ProjectStorageUpdater, watcher_updates_removes_qml_document)
                        {directoryPathId, qmlDocumentSourceId3, ModuleId{}, FileType::QmlDocument}});
     setQmlFileNames(u"/path", {"First.qml", "First2.qml"});
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(
-                    Field(&SynchronizationPackage::imports, IsEmpty()),
-                    Field(&SynchronizationPackage::types,
-                          UnorderedElementsAre(
-                              AllOf(IsStorageType("First.qml",
-                                                  Storage::Synchronization::ImportedType{},
-                                                  TypeTraitsKind::None,
-                                                  qmlDocumentSourceId1,
-                                                  Storage::Synchronization::ChangeLevel::Minimal),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(exampleModuleId, "FirstType", 1, 0),
-                                              IsExportedType(pathModuleId, "First", -1, -1)))),
-                              AllOf(IsStorageType("First2.qml",
-                                                  Storage::Synchronization::ImportedType{},
-                                                  TypeTraitsKind::None,
-                                                  qmlDocumentSourceId2,
-                                                  Storage::Synchronization::ChangeLevel::Minimal),
-                                    Field(&Storage::Synchronization::Type::exportedTypes,
-                                          UnorderedElementsAre(
-                                              IsExportedType(exampleModuleId, "FirstType", 2, 2),
-                                              IsExportedType(pathModuleId, "First2", -1, -1)))))),
-                    Field(&SynchronizationPackage::updatedSourceIds,
-                          UnorderedElementsAre(qmlDirPathSourceId,
-                                               qmlDocumentSourceId1,
-                                               qmlDocumentSourceId2,
-                                               qmlDocumentSourceId3)),
-                    Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                          UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
-                    Field(&SynchronizationPackage::fileStatuses,
-                          UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-                    Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
-                          UnorderedElementsAre(directoryPathId)),
-                    Field(&SynchronizationPackage::directoryInfos,
-                          UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId1,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument),
-                                               IsDirectoryInfo(directoryPathId,
-                                                               qmlDocumentSourceId2,
-                                                               ModuleId{},
-                                                               FileType::QmlDocument))))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(AllOf(
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field(
+                "SynchronizationPackage::types",
+                &SynchronizationPackage::types,
+                UnorderedElementsAre(
+                    AllOf(IsStorageType("First.qml",
+                                        ImportedType{},
+                                        TypeTraitsKind::None,
+                                        qmlDocumentSourceId1,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
+                                                     IsExportedType(pathModuleId, "First", -1, -1)))),
+                    AllOf(IsStorageType("First2.qml",
+                                        ImportedType{},
+                                        TypeTraitsKind::None,
+                                        qmlDocumentSourceId2,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
+                                UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
+                                                     IsExportedType(pathModuleId, "First2", -1, -1)))))),
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
+                  UnorderedElementsAre(qmlDirPathSourceId,
+                                       qmlDocumentSourceId1,
+                                       qmlDocumentSourceId2,
+                                       qmlDocumentSourceId3)),
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
+                  UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId3)),
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
+                  UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+                  UnorderedElementsAre(directoryPathId)),
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
+                  UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
+                                                       qmlDocumentSourceId1,
+                                                       ModuleId{},
+                                                       FileType::QmlDocument),
+                                       IsDirectoryInfo(directoryPathId,
+                                                       qmlDocumentSourceId2,
+                                                       ModuleId{},
+                                                       FileType::QmlDocument))))));
 
     updater.pathsWithIdsChanged({{directoryProjectChunkId, {directoryPathSourceId}}});
 }
@@ -2746,33 +3020,41 @@ TEST_F(ProjectStorageUpdater, watcher_updates_removes_qml_document_in_qmldir_onl
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(
                       AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                        IsExportedType(pathModuleId, "First", -1, -1)))),
                       AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "First2", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -2802,35 +3084,42 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directories_add_qml_document_to_qm
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -2859,33 +3148,41 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directories_remove_qml_document_fr
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, IsEmpty()),
-            Field(&SynchronizationPackage::types,
+            Field("SynchronizationPackage::imports", &SynchronizationPackage::imports, IsEmpty()),
+            Field("SynchronizationPackage::types",
+                  &SynchronizationPackage::types,
                   UnorderedElementsAre(
                       AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                        IsExportedType(pathModuleId, "First", -1, -1)))),
                       AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{},
+                                          ImportedType{},
                                           TypeTraitsKind::None,
                                           qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::Minimal),
-                            Field(&Storage::Synchronization::Type::exportedTypes,
+                                          ChangeLevel::Minimal),
+                            Field("Type::exportedTypes",
+                                  &Type::exportedTypes,
                                   UnorderedElementsAre(IsExportedType(pathModuleId, "First2", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                        qmlDocumentSourceId1,
                                                        ModuleId{},
@@ -2910,48 +3207,58 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directories_dont_update_qml_docume
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -2973,48 +3280,58 @@ TEST_F(ProjectStorageUpdater, watcher_updates_qmldirs_dont_update_qml_documents_
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{},
+                                        ImportedType{},
                                         TypeTraitsKind::None,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Minimal),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Minimal),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId, qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -3033,75 +3350,88 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directory_but_not_qmldir)
                        {directoryPathId, qmlDocumentSourceId2, exampleModuleId, FileType::QmlDocument}});
     setFilesDontChanged({qmlDirPathSourceId});
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports,
-                  UnorderedElementsAre(import1, import2, import4, import5)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      Eq(objectType),
-                      Eq(itemType),
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmltypesPathSourceId,
-                                       qmltypes2PathSourceId,
-                                       qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
-                                       IsFileStatus(qmltypes2PathSourceId, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmltypesPathSourceId,
-                                       qmltypes2PathSourceId,
-                                       qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2, import4, import5)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              Eq(objectType),
+                              Eq(itemType),
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmltypesPathSourceId,
+                                               qmltypes2PathSourceId,
+                                               qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
+                                               IsFileStatus(qmltypes2PathSourceId, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmltypesPathSourceId,
+                                               qmltypes2PathSourceId,
+                                               qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.pathsWithIdsChanged({{directoryProjectChunkId, {directoryPathSourceId}}});
 }
 
 TEST_F(ProjectStorageUpdater, watcher_updates_qml_documents)
 {
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmlDocumentProjectChunkId, {qmlDocumentSourceId1, qmlDocumentSourceId2}}});
@@ -3112,23 +3442,31 @@ TEST_F(ProjectStorageUpdater, watcher_updates_removed_qml_documents)
     setFilesRemoved({qmlDocumentSourceId2});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(
-                    Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1)),
-                    Field(&SynchronizationPackage::types,
-                          UnorderedElementsAre(AllOf(
-                              IsStorageType("First.qml",
-                                            Storage::Synchronization::ImportedType{"Object"},
-                                            TypeTraitsKind::Reference,
-                                            qmlDocumentSourceId1,
-                                            Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                              Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-                    Field(&SynchronizationPackage::updatedSourceIds,
-                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-                    Field(&SynchronizationPackage::fileStatuses,
-                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21))),
-                    Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-                    Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+                synchronize(
+                    AllOf(Field("SynchronizationPackage::imports",
+                                &SynchronizationPackage::imports,
+                                UnorderedElementsAre(import1)),
+                          Field("SynchronizationPackage::types",
+                                &SynchronizationPackage::types,
+                                UnorderedElementsAre(AllOf(
+                                    IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                          Field("SynchronizationPackage::updatedSourceIds",
+                                &SynchronizationPackage::updatedSourceIds,
+                                UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                          Field("SynchronizationPackage::fileStatuses",
+                                &SynchronizationPackage::fileStatuses,
+                                UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21))),
+                          Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                                &SynchronizationPackage::updatedFileStatusSourceIds,
+                                UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                          Field("SynchronizationPackage::directoryInfos",
+                                &SynchronizationPackage::directoryInfos,
+                                IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmlDocumentProjectChunkId, {qmlDocumentSourceId1, qmlDocumentSourceId2}}});
@@ -3159,18 +3497,25 @@ TEST_F(ProjectStorageUpdater, watcher_updates_qmltypes)
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::imports,
+                    AllOf(Field("SynchronizationPackage::imports",
+                                &SynchronizationPackage::imports,
                                 UnorderedElementsAre(import4, import5)),
-                          Field(&SynchronizationPackage::types,
+                          Field("SynchronizationPackage::types",
+                                &SynchronizationPackage::types,
                                 UnorderedElementsAre(Eq(objectType), Eq(itemType))),
-                          Field(&SynchronizationPackage::updatedSourceIds,
+                          Field("SynchronizationPackage::updatedSourceIds",
+                                &SynchronizationPackage::updatedSourceIds,
                                 UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)),
-                          Field(&SynchronizationPackage::fileStatuses,
+                          Field("SynchronizationPackage::fileStatuses",
+                                &SynchronizationPackage::fileStatuses,
                                 UnorderedElementsAre(IsFileStatus(qmltypesPathSourceId, 1, 21),
                                                      IsFileStatus(qmltypes2PathSourceId, 1, 21))),
-                          Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+                          Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                                &SynchronizationPackage::updatedFileStatusSourceIds,
                                 UnorderedElementsAre(qmltypesPathSourceId, qmltypes2PathSourceId)),
-                          Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+                          Field("SynchronizationPackage::directoryInfos",
+                                &SynchronizationPackage::directoryInfos,
+                                IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmltypesProjectChunkId, {qmltypesPathSourceId, qmltypes2PathSourceId}}});
@@ -3209,20 +3554,28 @@ TEST_F(ProjectStorageUpdater, watcher_updates_removed_qmltypes_with_updated_qmld
 
     EXPECT_CALL(projectStorageMock,
                 synchronize(
-                    AllOf(Field(&SynchronizationPackage::imports, UnorderedElementsAre(import5)),
-                          Field(&SynchronizationPackage::types, UnorderedElementsAre(Eq(itemType))),
-                          Field(&SynchronizationPackage::updatedSourceIds,
+                    AllOf(Field("SynchronizationPackage::imports",
+                                &SynchronizationPackage::imports,
+                                UnorderedElementsAre(import5)),
+                          Field("SynchronizationPackage::types",
+                                &SynchronizationPackage::types,
+                                UnorderedElementsAre(Eq(itemType))),
+                          Field("SynchronizationPackage::updatedSourceIds",
+                                &SynchronizationPackage::updatedSourceIds,
                                 UnorderedElementsAre(qmlDirPathSourceId,
                                                      qmltypesPathSourceId,
                                                      qmltypes2PathSourceId)),
-                          Field(&SynchronizationPackage::fileStatuses,
+                          Field("SynchronizationPackage::fileStatuses",
+                                &SynchronizationPackage::fileStatuses,
                                 UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                                      IsFileStatus(qmltypes2PathSourceId, 1, 21))),
-                          Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+                          Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                                &SynchronizationPackage::updatedFileStatusSourceIds,
                                 UnorderedElementsAre(qmlDirPathSourceId,
                                                      qmltypesPathSourceId,
                                                      qmltypes2PathSourceId)),
-                          Field(&SynchronizationPackage::directoryInfos,
+                          Field("SynchronizationPackage::directoryInfos",
+                                &SynchronizationPackage::directoryInfos,
                                 UnorderedElementsAre(IsDirectoryInfo(directoryPathId,
                                                                      qmltypes2PathSourceId,
                                                                      exampleCppNativeModuleId,
@@ -3272,49 +3625,59 @@ TEST_F(ProjectStorageUpdater, watcher_updates_directories_and_but_not_included_q
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2, qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(directoryPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(directoryPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -3339,52 +3702,62 @@ TEST_F(ProjectStorageUpdater, watcher_updates_qmldir_and_but_not_included_qml_do
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2, import3)),
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
+                  UnorderedElementsAre(import1, import2, import3)),
             Field(
                 &SynchronizationPackage::types,
                 UnorderedElementsAre(
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId1, ModuleId{}, FileType::QmlDocument),
                       IsDirectoryInfo(directoryPathId, qmlDocumentSourceId2, ModuleId{}, FileType::QmlDocument),
@@ -3421,7 +3794,8 @@ TEST_F(ProjectStorageUpdater, watcher_updates_qmldir_and_but_not_included_qmltyp
     EXPECT_CALL(
         projectStorageMock,
         synchronize(AllOf(
-            Field(&SynchronizationPackage::imports,
+            Field("SynchronizationPackage::imports",
+                  &SynchronizationPackage::imports,
                   UnorderedElementsAre(import1, import2, import3, import4, import5)),
             Field(
                 &SynchronizationPackage::types,
@@ -3429,53 +3803,61 @@ TEST_F(ProjectStorageUpdater, watcher_updates_qmldir_and_but_not_included_qmltyp
                     Eq(objectType),
                     Eq(itemType),
                     AllOf(IsStorageType("First.qml",
-                                        Storage::Synchronization::ImportedType{"Object"},
+                                        ImportedType{"Object"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId1,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 1, 0),
                                                      IsExportedType(pathModuleId, "First", -1, -1)))),
                     AllOf(IsStorageType("First2.qml",
-                                        Storage::Synchronization::ImportedType{"Object2"},
+                                        ImportedType{"Object2"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId2,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "FirstType", 2, 2),
                                                      IsExportedType(pathModuleId, "First2", -1, -1)))),
                     AllOf(IsStorageType("Second.qml",
-                                        Storage::Synchronization::ImportedType{"Object3"},
+                                        ImportedType{"Object3"},
                                         TypeTraitsKind::Reference,
                                         qmlDocumentSourceId3,
-                                        Storage::Synchronization::ChangeLevel::Full),
-                          Field(&Storage::Synchronization::Type::exportedTypes,
+                                        ChangeLevel::Full),
+                          Field("Type::exportedTypes",
+                                &Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(exampleModuleId, "SecondType", 2, 2),
                                                      IsExportedType(pathModuleId, "Second", -1, -1)))))),
-            Field(&SynchronizationPackage::updatedSourceIds,
+            Field("SynchronizationPackage::updatedSourceIds",
+                  &SynchronizationPackage::updatedSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmltypesPathSourceId,
                                        qmltypes2PathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
                   UnorderedElementsAre(qmlDirPathSourceId,
                                        qmltypesPathSourceId,
                                        qmltypes2PathSourceId,
                                        qmlDocumentSourceId1,
                                        qmlDocumentSourceId2,
                                        qmlDocumentSourceId3)),
-            Field(&SynchronizationPackage::fileStatuses,
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
                   UnorderedElementsAre(IsFileStatus(qmlDirPathSourceId, 1, 21),
                                        IsFileStatus(qmltypesPathSourceId, 1, 21),
                                        IsFileStatus(qmltypes2PathSourceId, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId1, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId2, 1, 21),
                                        IsFileStatus(qmlDocumentSourceId3, 1, 21))),
-            Field(&SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
+            Field("SynchronizationPackage::updatedDirectoryInfoDirectoryIds",
+                  &SynchronizationPackage::updatedDirectoryInfoDirectoryIds,
                   UnorderedElementsAre(directoryPathId)),
-            Field(&SynchronizationPackage::directoryInfos,
+            Field("SynchronizationPackage::directoryInfos",
+                  &SynchronizationPackage::directoryInfos,
                   UnorderedElementsAre(
                       IsDirectoryInfo(directoryPathId,
                                       qmltypesPathSourceId,
@@ -3526,43 +3908,49 @@ TEST_F(ProjectStorageUpdater, input_is_reused_next_call_if_an_error_happens)
         {{qmltypesProjectChunkId, {qmltypesPathSourceId, qmltypes2PathSourceId}}});
     ON_CALL(projectStorageMock, synchronize(_)).WillByDefault(Return());
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports,
-                  UnorderedElementsAre(import1, import2, import4, import5)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      Eq(objectType),
-                      Eq(itemType),
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2,
-                                       qmltypesPathSourceId,
-                                       qmltypes2PathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21),
-                                       IsFileStatus(qmltypesPathSourceId, 1, 21),
-                                       IsFileStatus(qmltypes2PathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2,
-                                       qmltypesPathSourceId,
-                                       qmltypes2PathSourceId)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2, import4, import5)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              Eq(objectType),
+                              Eq(itemType),
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2,
+                                               qmltypesPathSourceId,
+                                               qmltypes2PathSourceId)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21),
+                                               IsFileStatus(qmltypesPathSourceId, 1, 21),
+                                               IsFileStatus(qmltypes2PathSourceId, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2,
+                                               qmltypesPathSourceId,
+                                               qmltypes2PathSourceId)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmlDocumentProjectChunkId, {qmlDocumentSourceId1, qmlDocumentSourceId2}}});
@@ -3585,43 +3973,49 @@ TEST_F(ProjectStorageUpdater, input_is_reused_next_call_if_an_error_happens_and_
         {{qmltypesProjectChunkId, {qmltypesPathSourceId, qmltypes2PathSourceId}}});
     ON_CALL(projectStorageMock, synchronize(_)).WillByDefault(Return());
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports,
-                  UnorderedElementsAre(import1, import2, import4, import5)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      Eq(objectType),
-                      Eq(itemType),
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2,
-                                       qmltypesPathSourceId,
-                                       qmltypes2PathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21),
-                                       IsFileStatus(qmltypesPathSourceId, 1, 21),
-                                       IsFileStatus(qmltypes2PathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2,
-                                       qmltypesPathSourceId,
-                                       qmltypes2PathSourceId)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2, import4, import5)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              Eq(objectType),
+                              Eq(itemType),
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2,
+                                               qmltypesPathSourceId,
+                                               qmltypes2PathSourceId)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21),
+                                               IsFileStatus(qmltypesPathSourceId, 1, 21),
+                                               IsFileStatus(qmltypes2PathSourceId, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2,
+                                               qmltypesPathSourceId,
+                                               qmltypes2PathSourceId)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmltypesProjectChunkId, {qmltypesPathSourceId, qmltypes2PathSourceId}},
@@ -3648,43 +4042,49 @@ TEST_F(ProjectStorageUpdater, input_is_reused_next_call_if_an_error_happens_and_
         {{qmlDocumentProjectChunkId, {qmlDocumentSourceId1, qmlDocumentSourceId2}}});
     ON_CALL(projectStorageMock, synchronize(_)).WillByDefault(Return());
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports,
-                  UnorderedElementsAre(import1, import2, import4, import5)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      Eq(objectType),
-                      Eq(itemType),
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2,
-                                       qmltypesPathSourceId,
-                                       qmltypes2PathSourceId)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21),
-                                       IsFileStatus(qmltypesPathSourceId, 1, 21),
-                                       IsFileStatus(qmltypes2PathSourceId, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1,
-                                       qmlDocumentSourceId2,
-                                       qmltypesPathSourceId,
-                                       qmltypes2PathSourceId)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2, import4, import5)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              Eq(objectType),
+                              Eq(itemType),
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2,
+                                               qmltypesPathSourceId,
+                                               qmltypes2PathSourceId)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21),
+                                               IsFileStatus(qmltypesPathSourceId, 1, 21),
+                                               IsFileStatus(qmltypes2PathSourceId, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1,
+                                               qmlDocumentSourceId2,
+                                               qmltypesPathSourceId,
+                                               qmltypes2PathSourceId)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmltypesProjectChunkId, {qmltypesPathSourceId, qmltypes2PathSourceId}},
@@ -3705,32 +4105,39 @@ TEST_F(ProjectStorageUpdater, input_is_cleared_after_successful_update)
     updater.pathsWithIdsChanged(
         {{qmltypesProjectChunkId, {qmltypesPathSourceId, qmltypes2PathSourceId}}});
 
-    EXPECT_CALL(
-        projectStorageMock,
-        synchronize(AllOf(
-            Field(&SynchronizationPackage::imports, UnorderedElementsAre(import1, import2)),
-            Field(&SynchronizationPackage::types,
-                  UnorderedElementsAre(
-                      AllOf(IsStorageType("First.qml",
-                                          Storage::Synchronization::ImportedType{"Object"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId1,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())),
-                      AllOf(IsStorageType("First2.qml",
-                                          Storage::Synchronization::ImportedType{"Object2"},
-                                          TypeTraitsKind::Reference,
-                                          qmlDocumentSourceId2,
-                                          Storage::Synchronization::ChangeLevel::ExcludeExportedTypes),
-                            Field(&Storage::Synchronization::Type::exportedTypes, IsEmpty())))),
-            Field(&SynchronizationPackage::updatedSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::fileStatuses,
-                  UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
-                                       IsFileStatus(qmlDocumentSourceId2, 1, 21))),
-            Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                  UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
-            Field(&SynchronizationPackage::directoryInfos, IsEmpty()))));
+    EXPECT_CALL(projectStorageMock,
+                synchronize(AllOf(
+                    Field("SynchronizationPackage::imports",
+                          &SynchronizationPackage::imports,
+                          UnorderedElementsAre(import1, import2)),
+                    Field("SynchronizationPackage::types",
+                          &SynchronizationPackage::types,
+                          UnorderedElementsAre(
+                              AllOf(IsStorageType("First.qml",
+                                                  ImportedType{"Object"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId1,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())),
+                              AllOf(IsStorageType("First2.qml",
+                                                  ImportedType{"Object2"},
+                                                  TypeTraitsKind::Reference,
+                                                  qmlDocumentSourceId2,
+                                                  ChangeLevel::ExcludeExportedTypes),
+                                    Field("Type::exportedTypes", &Type::exportedTypes, IsEmpty())))),
+                    Field("SynchronizationPackage::updatedSourceIds",
+                          &SynchronizationPackage::updatedSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::fileStatuses",
+                          &SynchronizationPackage::fileStatuses,
+                          UnorderedElementsAre(IsFileStatus(qmlDocumentSourceId1, 1, 21),
+                                               IsFileStatus(qmlDocumentSourceId2, 1, 21))),
+                    Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                          &SynchronizationPackage::updatedFileStatusSourceIds,
+                          UnorderedElementsAre(qmlDocumentSourceId1, qmlDocumentSourceId2)),
+                    Field("SynchronizationPackage::directoryInfos",
+                          &SynchronizationPackage::directoryInfos,
+                          IsEmpty()))));
 
     updater.pathsWithIdsChanged(
         {{qmlDocumentProjectChunkId, {qmlDocumentSourceId1, qmlDocumentSourceId2}}});
@@ -3755,17 +4162,21 @@ TEST_F(ProjectStorageUpdater, update_property_editor_panes)
     setFilesChanged({directorySourceId});
     auto qmlModuleId = storage.moduleId("QML", ModuleKind::QmlLibrary);
 
-    EXPECT_CALL(projectStorageMock,
-                synchronize(
-                    AllOf(Field(&SynchronizationPackage::fileStatuses,
-                                UnorderedElementsAre(IsFileStatus(directorySourceId, 1, 21))),
-                          Field(&SynchronizationPackage::updatedFileStatusSourceIds,
-                                UnorderedElementsAre(directorySourceId)),
-                          Field(&SynchronizationPackage::propertyEditorQmlPaths,
-                                Contains(IsPropertyEditorQmlPath(
-                                    qmlModuleId, "QtObject", sourceId, directoryId))),
-                          Field(&SynchronizationPackage::updatedPropertyEditorQmlPathSourceContextIds,
-                                ElementsAre(directoryId)))));
+    EXPECT_CALL(
+        projectStorageMock,
+        synchronize(AllOf(
+            Field("SynchronizationPackage::fileStatuses",
+                  &SynchronizationPackage::fileStatuses,
+                  UnorderedElementsAre(IsFileStatus(directorySourceId, 1, 21))),
+            Field("SynchronizationPackage::updatedFileStatusSourceIds",
+                  &SynchronizationPackage::updatedFileStatusSourceIds,
+                  UnorderedElementsAre(directorySourceId)),
+            Field("SynchronizationPackage::propertyEditorQmlPaths",
+                  &SynchronizationPackage::propertyEditorQmlPaths,
+                  Contains(IsPropertyEditorQmlPath(qmlModuleId, "QtObject", sourceId, directoryId))),
+            Field("SynchronizationPackage::updatedPropertyEditorQmlPathSourceContextIds",
+                  &SynchronizationPackage::updatedPropertyEditorQmlPathSourceContextIds,
+                  ElementsAre(directoryId)))));
 
     updater.update({.propertyEditorResourcesPath = propertyEditorQmlPath});
 }
@@ -3796,12 +4207,14 @@ TEST_F(ProjectStorageUpdater, update_property_editor_specifics)
     EXPECT_CALL(
         projectStorageMock,
         synchronize(
-            AllOf(Field(&SynchronizationPackage::propertyEditorQmlPaths,
+            AllOf(Field("SynchronizationPackage::propertyEditorQmlPaths",
+                        &SynchronizationPackage::propertyEditorQmlPaths,
                         IsSupersetOf(
                             {IsPropertyEditorQmlPath(qtQuickModuleId, "Text", textSourceId, qtQuickDirectoryId),
                              IsPropertyEditorQmlPath(
                                  controlsModuleId, "Button", buttonSourceId, controlsDirectoryId)})),
-                  Field(&SynchronizationPackage::updatedPropertyEditorQmlPathSourceContextIds,
+                  Field("SynchronizationPackage::updatedPropertyEditorQmlPathSourceContextIds",
+                        &SynchronizationPackage::updatedPropertyEditorQmlPathSourceContextIds,
                         ElementsAre(qtQuickDirectoryId, controlsDirectoryId)))));
 
     updater.update({.propertyEditorResourcesPath = propertyEditorQmlPath});
@@ -3835,7 +4248,8 @@ TEST_F(ProjectStorageUpdater, update_type_annotations)
     itemTraits.canBeContainer = QmlDesigner::FlagIs::True;
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::typeAnnotations,
+                synchronize(AllOf(Field("SynchronizationPackage::typeAnnotations",
+                                        &SynchronizationPackage::typeAnnotations,
                                         IsSupersetOf({IsTypeAnnotation(itemSourceId,
                                                                        itemLibraryPathSourceContextId,
                                                                        "Item",
@@ -3852,7 +4266,8 @@ TEST_F(ProjectStorageUpdater, update_type_annotations)
                                                                        _,
                                                                        _,
                                                                        _)})),
-                                  Field(&SynchronizationPackage::updatedTypeAnnotationSourceIds,
+                                  Field("SynchronizationPackage::updatedTypeAnnotationSourceIds",
+                                        &SynchronizationPackage::updatedTypeAnnotationSourceIds,
                                         IsSupersetOf({itemSourceId, buttonSourceId})))));
 
     updater.update({.typeAnnotationPaths = {itemLibraryPath}});
@@ -3872,7 +4287,8 @@ TEST_F(ProjectStorageUpdater, update_changed_type_annotation)
     itemTraits.canBeContainer = QmlDesigner::FlagIs::True;
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::typeAnnotations,
+                synchronize(AllOf(Field("SynchronizationPackage::typeAnnotations",
+                                        &SynchronizationPackage::typeAnnotations,
                                         IsSupersetOf({IsTypeAnnotation(itemSourceId,
                                                                        itemLibraryPathSourceContextId,
                                                                        "Item",
@@ -3889,7 +4305,8 @@ TEST_F(ProjectStorageUpdater, update_changed_type_annotation)
                                                                        _,
                                                                        _,
                                                                        _)})),
-                                  Field(&SynchronizationPackage::updatedTypeAnnotationSourceIds,
+                                  Field("SynchronizationPackage::updatedTypeAnnotationSourceIds",
+                                        &SynchronizationPackage::updatedTypeAnnotationSourceIds,
                                         IsSupersetOf({itemSourceId, buttonSourceId})))));
 
     updater.update({.typeAnnotationPaths = {itemLibraryPath}});
@@ -3915,8 +4332,11 @@ TEST_F(ProjectStorageUpdater, update_type_annotations_removed_meta_info_file)
     setFilesDontChanged({itemSourceId, buttonSourceId});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::typeAnnotations, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedTypeAnnotationSourceIds,
+                synchronize(AllOf(Field("SynchronizationPackage::typeAnnotations",
+                                        &SynchronizationPackage::typeAnnotations,
+                                        IsEmpty()),
+                                  Field("SynchronizationPackage::updatedTypeAnnotationSourceIds",
+                                        &SynchronizationPackage::updatedTypeAnnotationSourceIds,
                                         IsSupersetOf({itemSourceId, buttonSourceId})))));
 
     updater.update({.typeAnnotationPaths = {itemLibraryPath}});
@@ -3943,8 +4363,11 @@ TEST_F(ProjectStorageUpdater, update_type_annotations_removed_directory)
     setFilesDontExists({itemLibraryPathSourceId, buttonSourceId, itemSourceId});
 
     EXPECT_CALL(projectStorageMock,
-                synchronize(AllOf(Field(&SynchronizationPackage::typeAnnotations, IsEmpty()),
-                                  Field(&SynchronizationPackage::updatedTypeAnnotationSourceIds,
+                synchronize(AllOf(Field("SynchronizationPackage::typeAnnotations",
+                                        &SynchronizationPackage::typeAnnotations,
+                                        IsEmpty()),
+                                  Field("SynchronizationPackage::updatedTypeAnnotationSourceIds",
+                                        &SynchronizationPackage::updatedTypeAnnotationSourceIds,
                                         IsSupersetOf({buttonSourceId, itemSourceId})))));
 
     updater.update({.typeAnnotationPaths = {itemLibraryPath}});
diff --git a/tests/unit/tests/unittests/projectstorage/qmldocumentparser-test.cpp b/tests/unit/tests/unittests/projectstorage/qmldocumentparser-test.cpp
index 0db9dbed702..ebcb9c1a3cc 100644
--- a/tests/unit/tests/unittests/projectstorage/qmldocumentparser-test.cpp
+++ b/tests/unit/tests/unittests/projectstorage/qmldocumentparser-test.cpp
@@ -313,9 +313,9 @@ TEST_F(QmlDocumentParser, functions)
     ASSERT_THAT(type.functionDeclarations,
                 UnorderedElementsAre(
                     AllOf(IsFunctionDeclaration("otherFunction", ""),
-                          Field(&Synchronization::FunctionDeclaration::parameters, IsEmpty())),
+                          Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters, IsEmpty())),
                     AllOf(IsFunctionDeclaration("someScript", ""),
-                          Field(&Synchronization::FunctionDeclaration::parameters,
+                          Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters,
                                 ElementsAre(IsParameter("x", ""), IsParameter("y", ""))))));
 }
 
@@ -331,10 +331,10 @@ TEST_F(QmlDocumentParser, signals)
     ASSERT_THAT(type.signalDeclarations,
                 UnorderedElementsAre(
                     AllOf(IsSignalDeclaration("someSignal"),
-                          Field(&Synchronization::SignalDeclaration::parameters,
+                          Field("Synchronization::SignalDeclaration::parameters", &Synchronization::SignalDeclaration::parameters,
                                 ElementsAre(IsParameter("x", "int"), IsParameter("y", "real")))),
                     AllOf(IsSignalDeclaration("signal2"),
-                          Field(&Synchronization::SignalDeclaration::parameters, IsEmpty()))));
+                          Field("Synchronization::SignalDeclaration::parameters", &Synchronization::SignalDeclaration::parameters, IsEmpty()))));
 }
 
 TEST_F(QmlDocumentParser, enumeration)
@@ -348,13 +348,13 @@ TEST_F(QmlDocumentParser, enumeration)
     ASSERT_THAT(type.enumerationDeclarations,
                 UnorderedElementsAre(
                     AllOf(IsEnumeration("Color"),
-                          Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
+                          Field("Synchronization::EnumerationDeclaration::enumeratorDeclarations", &Synchronization::EnumerationDeclaration::enumeratorDeclarations,
                                 ElementsAre(IsEnumerator("red", 0),
                                             IsEnumerator("green", 1),
                                             IsEnumerator("blue", 10),
                                             IsEnumerator("white", 11)))),
                     AllOf(IsEnumeration("State"),
-                          Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
+                          Field("Synchronization::EnumerationDeclaration::enumeratorDeclarations", &Synchronization::EnumerationDeclaration::enumeratorDeclarations,
                                 ElementsAre(IsEnumerator("On", 0), IsEnumerator("Off", 1))))));
 }
 
diff --git a/tests/unit/tests/unittests/projectstorage/qmltypesparser-test.cpp b/tests/unit/tests/unittests/projectstorage/qmltypesparser-test.cpp
index aab92287fe9..d56004a15c1 100644
--- a/tests/unit/tests/unittests/projectstorage/qmltypesparser-test.cpp
+++ b/tests/unit/tests/unittests/projectstorage/qmltypesparser-test.cpp
@@ -80,7 +80,7 @@ MATCHER_P(IsSingleton, value, std::string(negation ? "isn't singleton " : "is si
 template<typename Matcher>
 auto IsTypeTrait(const Matcher &matcher)
 {
-    return Field(&Synchronization::Type::traits, matcher);
+    return Field("Synchronization::Type::traits", &Synchronization::Type::traits, matcher);
 }
 
 MATCHER_P3(IsPropertyDeclaration,
@@ -382,7 +382,7 @@ TEST_F(QmlTypesParser, properties_with_qualified_types)
 
     ASSERT_THAT(types,
                 Contains(
-                    Field(&Synchronization::Type::propertyDeclarations,
+                    Field("Synchronization::Type::propertyDeclarations", &Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("values",
                                                     Synchronization::ImportedType{"Qt::Vector"},
@@ -408,7 +408,7 @@ TEST_F(QmlTypesParser, properties_without_type)
 
     ASSERT_THAT(types,
                 ElementsAre(
-                    Field(&Synchronization::Type::propertyDeclarations,
+                    Field("Synchronization::Type::propertyDeclarations", &Synchronization::Type::propertyDeclarations,
                           UnorderedElementsAre(
                               IsPropertyDeclaration("target",
                                                     Synchronization::ImportedType{"QObject"},
@@ -444,17 +444,17 @@ TEST_F(QmlTypesParser, functions)
                     &Synchronization::Type::functionDeclarations,
                     UnorderedElementsAre(
                         AllOf(IsFunctionDeclaration("advance", ""),
-                              Field(&Synchronization::FunctionDeclaration::parameters,
+                              Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("frames", "int"),
                                                          IsParameter("fps", "double")))),
                         AllOf(IsFunctionDeclaration("isImageLoading", "bool"),
-                              Field(&Synchronization::FunctionDeclaration::parameters,
+                              Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("url", "QUrl")))),
                         AllOf(IsFunctionDeclaration("getContext", ""),
-                              Field(&Synchronization::FunctionDeclaration::parameters,
+                              Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("args", "QQmlV4Function")))),
                         AllOf(IsFunctionDeclaration("movieUpdate", ""),
-                              Field(&Synchronization::FunctionDeclaration::parameters, IsEmpty()))))));
+                              Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters, IsEmpty()))))));
 }
 
 TEST_F(QmlTypesParser, skip_java_script_functions)
@@ -470,7 +470,7 @@ TEST_F(QmlTypesParser, skip_java_script_functions)
 
     parser.parse(source, imports, types, directoryInfo);
 
-    ASSERT_THAT(types, ElementsAre(Field(&Synchronization::Type::functionDeclarations, IsEmpty())));
+    ASSERT_THAT(types, ElementsAre(Field("Synchronization::Type::functionDeclarations", &Synchronization::Type::functionDeclarations, IsEmpty())));
 }
 
 TEST_F(QmlTypesParser, functions_with_qualified_types)
@@ -492,10 +492,10 @@ TEST_F(QmlTypesParser, functions_with_qualified_types)
 
     ASSERT_THAT(types,
                 Contains(
-                    Field(&Synchronization::Type::functionDeclarations,
+                    Field("Synchronization::Type::functionDeclarations", &Synchronization::Type::functionDeclarations,
                           UnorderedElementsAre(AllOf(
                               IsFunctionDeclaration("values", ""),
-                              Field(&Synchronization::FunctionDeclaration::parameters,
+                              Field("Synchronization::FunctionDeclaration::parameters", &Synchronization::FunctionDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("values", "Qt::Vector"),
                                                          IsParameter("items", "Qt::List"),
                                                          IsParameter("values2", "Qt::Vector"))))))));
@@ -526,17 +526,17 @@ TEST_F(QmlTypesParser, signals)
     parser.parse(source, imports, types, directoryInfo);
 
     ASSERT_THAT(types,
-                ElementsAre(Field(&Synchronization::Type::signalDeclarations,
+                ElementsAre(Field("Synchronization::Type::signalDeclarations", &Synchronization::Type::signalDeclarations,
                                   UnorderedElementsAre(
                                       AllOf(IsSignalDeclaration("advance"),
-                                            Field(&Synchronization::SignalDeclaration::parameters,
+                                            Field("Synchronization::SignalDeclaration::parameters", &Synchronization::SignalDeclaration::parameters,
                                                   UnorderedElementsAre(IsParameter("frames", "int"),
                                                                        IsParameter("fps", "double")))),
                                       AllOf(IsSignalDeclaration("isImageLoading"),
-                                            Field(&Synchronization::SignalDeclaration::parameters,
+                                            Field("Synchronization::SignalDeclaration::parameters", &Synchronization::SignalDeclaration::parameters,
                                                   UnorderedElementsAre(IsParameter("url", "QUrl")))),
                                       AllOf(IsSignalDeclaration("getContext"),
-                                            Field(&Synchronization::SignalDeclaration::parameters,
+                                            Field("Synchronization::SignalDeclaration::parameters", &Synchronization::SignalDeclaration::parameters,
                                                   UnorderedElementsAre(
                                                       IsParameter("args", "QQmlV4Function"))))))));
 }
@@ -560,10 +560,10 @@ TEST_F(QmlTypesParser, signals_with_qualified_types)
 
     ASSERT_THAT(types,
                 Contains(
-                    Field(&Synchronization::Type::signalDeclarations,
+                    Field("Synchronization::Type::signalDeclarations", &Synchronization::Type::signalDeclarations,
                           UnorderedElementsAre(AllOf(
                               IsSignalDeclaration("values"),
-                              Field(&Synchronization::SignalDeclaration::parameters,
+                              Field("Synchronization::SignalDeclaration::parameters", &Synchronization::SignalDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("values", "Qt::Vector"),
                                                          IsParameter("items", "Qt::List"),
                                                          IsParameter("values2", "Qt::Vector"))))))));
@@ -596,13 +596,13 @@ TEST_F(QmlTypesParser, enumerations)
                     &Synchronization::Type::enumerationDeclarations,
                     UnorderedElementsAre(
                         AllOf(IsEnumeration("NamedColorSpace"),
-                              Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
+                              Field("Synchronization::EnumerationDeclaration::enumeratorDeclarations", &Synchronization::EnumerationDeclaration::enumeratorDeclarations,
                                     UnorderedElementsAre(IsEnumerator("Unknown"),
                                                          IsEnumerator("SRgb"),
                                                          IsEnumerator("AdobeRgb"),
                                                          IsEnumerator("DisplayP3")))),
                         AllOf(IsEnumeration("VerticalLayoutDirection"),
-                              Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
+                              Field("Synchronization::EnumerationDeclaration::enumeratorDeclarations", &Synchronization::EnumerationDeclaration::enumeratorDeclarations,
                                     UnorderedElementsAre(IsEnumerator("TopToBottom"),
                                                          IsEnumerator("BottomToTop"))))))));
 }
@@ -640,7 +640,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type)
                          Synchronization::ImportedType{},
                          traits,
                          qmltypesFileSourceId),
-                  Field(&Synchronization::Type::exportedTypes,
+                  Field("Synchronization::Type::exportedTypes", &Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                             "QObject::NamedColorSpace",
                                                             QmlDesigner::Storage::Version{})))),
@@ -649,7 +649,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type)
                          Synchronization::ImportedType{},
                          traits,
                          qmltypesFileSourceId),
-                  Field(&Synchronization::Type::exportedTypes,
+                  Field("Synchronization::Type::exportedTypes", &Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                             "QObject::VerticalLayoutDirection",
                                                             QmlDesigner::Storage::Version{})))),
@@ -685,7 +685,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type_with_alias)
                                  Synchronization::ImportedType{},
                                  traits,
                                  qmltypesFileSourceId),
-                          Field(&Synchronization::Type::exportedTypes,
+                          Field("Synchronization::Type::exportedTypes", &Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpace",
                                                                     QmlDesigner::Storage::Version{}),
@@ -733,7 +733,7 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type_with_alias_too)
                                  Synchronization::ImportedType{},
                                  traits,
                                  qmltypesFileSourceId),
-                          Field(&Synchronization::Type::exportedTypes,
+                          Field("Synchronization::Type::exportedTypes", &Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpace",
                                                                     QmlDesigner::Storage::Version{}),
@@ -763,7 +763,7 @@ TEST_F(QmlTypesParser, enumeration_is_referenced_by_qualified_name)
     parser.parse(source, imports, types, directoryInfo);
 
     ASSERT_THAT(types,
-                Contains(Field(&Synchronization::Type::propertyDeclarations,
+                Contains(Field("Synchronization::Type::propertyDeclarations", &Synchronization::Type::propertyDeclarations,
                                ElementsAre(IsPropertyDeclaration(
                                    "colorSpace",
                                    Synchronization::ImportedType{"QObject::NamedColorSpace"},
@@ -791,7 +791,7 @@ TEST_F(QmlTypesParser, alias_enumeration_is_referenced_by_qualified_name)
     parser.parse(source, imports, types, directoryInfo);
 
     ASSERT_THAT(types,
-                Contains(Field(&Synchronization::Type::propertyDeclarations,
+                Contains(Field("Synchronization::Type::propertyDeclarations", &Synchronization::Type::propertyDeclarations,
                                ElementsAre(IsPropertyDeclaration(
                                    "colorSpace",
                                    Synchronization::ImportedType{"QObject::NamedColorSpaces"},
@@ -880,7 +880,7 @@ TEST_F(QmlTypesParser, default_property)
     parser.parse(source, imports, types, directoryInfo);
 
     ASSERT_THAT(types,
-                ElementsAre(Field(&Synchronization::Type::defaultPropertyName, Eq("children"))));
+                ElementsAre(Field("Synchronization::Type::defaultPropertyName", &Synchronization::Type::defaultPropertyName, Eq("children"))));
 }
 
 TEST_F(QmlTypesParser, skip_template_item)
diff --git a/tests/unit/tests/unittests/sqlite/sqlitecolumn-test.cpp b/tests/unit/tests/unittests/sqlite/sqlitecolumn-test.cpp
index f75deb65710..c42e4e1a6ab 100644
--- a/tests/unit/tests/unittests/sqlite/sqlitecolumn-test.cpp
+++ b/tests/unit/tests/unittests/sqlite/sqlitecolumn-test.cpp
@@ -27,10 +27,10 @@ protected:
 TEST_F(SqliteColumn, default_construct)
 {
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, IsEmpty()),
-                      Field(&Column::tableName, IsEmpty()),
-                      Field(&Column::type, ColumnType::None),
-                      Field(&Column::constraints, IsEmpty())));
+                AllOf(Field("Column::name", &Column::name, IsEmpty()),
+                      Field("Column::tableName", &Column::tableName, IsEmpty()),
+                      Field("Column::type", &Column::type, ColumnType::None),
+                      Field("Column::constraints", &Column::constraints, IsEmpty())));
 }
 
 TEST_F(SqliteColumn, clear)
@@ -43,10 +43,10 @@ TEST_F(SqliteColumn, clear)
     column.clear();
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, IsEmpty()),
-                      Field(&Column::tableName, IsEmpty()),
-                      Field(&Column::type, ColumnType::None),
-                      Field(&Column::constraints, IsEmpty())));
+                AllOf(Field("Column::name", &Column::name, IsEmpty()),
+                      Field("Column::tableName", &Column::tableName, IsEmpty()),
+                      Field("Column::type", &Column::type, ColumnType::None),
+                      Field("Column::constraints", &Column::constraints, IsEmpty())));
 }
 
 TEST_F(SqliteColumn, constructor)
@@ -61,16 +61,16 @@ TEST_F(SqliteColumn, constructor)
                                 Enforment::Deferred}}};
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("column")),
-                      Field(&Column::tableName, Eq("table")),
-                      Field(&Column::type, ColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("column")),
+                      Field("Column::tableName", &Column::tableName, Eq("table")),
+                      Field("Column::type", &Column::type, ColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("referencedTable")),
-                                      Field(&ForeignKey::column, Eq("referencedColumn")),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("referencedTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, Eq("referencedColumn")),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 TEST_F(SqliteColumn, flat_constructor)
@@ -85,16 +85,16 @@ TEST_F(SqliteColumn, flat_constructor)
                                 Enforment::Deferred}}};
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("column")),
-                      Field(&Column::tableName, Eq("table")),
-                      Field(&Column::type, ColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("column")),
+                      Field("Column::tableName", &Column::tableName, Eq("table")),
+                      Field("Column::type", &Column::type, ColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("referencedTable")),
-                                      Field(&ForeignKey::column, Eq("referencedColumn")),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("referencedTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, Eq("referencedColumn")),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 class SqliteStrictColumn : public ::testing::Test
@@ -108,10 +108,10 @@ protected:
 TEST_F(SqliteStrictColumn, default_construct)
 {
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, IsEmpty()),
-                      Field(&Column::tableName, IsEmpty()),
-                      Field(&Column::type, StrictColumnType::Any),
-                      Field(&Column::constraints, IsEmpty())));
+                AllOf(Field("Column::name", &Column::name, IsEmpty()),
+                      Field("Column::tableName", &Column::tableName, IsEmpty()),
+                      Field("Column::type", &Column::type, StrictColumnType::Any),
+                      Field("Column::constraints", &Column::constraints, IsEmpty())));
 }
 
 TEST_F(SqliteStrictColumn, clear)
@@ -124,10 +124,10 @@ TEST_F(SqliteStrictColumn, clear)
     column.clear();
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, IsEmpty()),
-                      Field(&Column::tableName, IsEmpty()),
-                      Field(&Column::type, StrictColumnType::Any),
-                      Field(&Column::constraints, IsEmpty())));
+                AllOf(Field("Column::name", &Column::name, IsEmpty()),
+                      Field("Column::tableName", &Column::tableName, IsEmpty()),
+                      Field("Column::type", &Column::type, StrictColumnType::Any),
+                      Field("Column::constraints", &Column::constraints, IsEmpty())));
 }
 
 TEST_F(SqliteStrictColumn, constructor)
@@ -142,16 +142,16 @@ TEST_F(SqliteStrictColumn, constructor)
                                 Enforment::Deferred}}};
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("column")),
-                      Field(&Column::tableName, Eq("table")),
-                      Field(&Column::type, StrictColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("column")),
+                      Field("Column::tableName", &Column::tableName, Eq("table")),
+                      Field("Column::type", &Column::type, StrictColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("referencedTable")),
-                                      Field(&ForeignKey::column, Eq("referencedColumn")),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("referencedTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, Eq("referencedColumn")),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 TEST_F(SqliteStrictColumn, flat_constructor)
@@ -166,16 +166,16 @@ TEST_F(SqliteStrictColumn, flat_constructor)
                                 Enforment::Deferred}}};
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("column")),
-                      Field(&Column::tableName, Eq("table")),
-                      Field(&Column::type, StrictColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("column")),
+                      Field("Column::tableName", &Column::tableName, Eq("table")),
+                      Field("Column::type", &Column::type, StrictColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("referencedTable")),
-                                      Field(&ForeignKey::column, Eq("referencedColumn")),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("referencedTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, Eq("referencedColumn")),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 } // namespace
diff --git a/tests/unit/tests/unittests/sqlite/sqlitestatement-test.cpp b/tests/unit/tests/unittests/sqlite/sqlitestatement-test.cpp
index 8d7a551ac32..7d54ba7ca10 100644
--- a/tests/unit/tests/unittests/sqlite/sqlitestatement-test.cpp
+++ b/tests/unit/tests/unittests/sqlite/sqlitestatement-test.cpp
@@ -665,7 +665,7 @@ TEST_F(SqliteStatement, write_sqlite_blob_value)
     statement.write(Sqlite::Value{bytes});
 
     ASSERT_THAT(readStatement.template optionalValue<Sqlite::Blob>(),
-                Optional(Field(&Sqlite::Blob::bytes, Eq(bytes))));
+                Optional(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, Eq(bytes))));
 }
 
 TEST_F(SqliteStatement, write_null_value_view)
@@ -717,7 +717,7 @@ TEST_F(SqliteStatement, write_sqlite_blob_value_view)
     statement.write(Sqlite::ValueView::create(bytes));
 
     ASSERT_THAT(readStatement.template optionalValue<Sqlite::Blob>(),
-                Optional(Field(&Sqlite::Blob::bytes, Eq(bytes))));
+                Optional(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, Eq(bytes))));
 }
 
 TEST_F(SqliteStatement, write_empty_blobs)
@@ -754,7 +754,7 @@ TEST_F(SqliteStatement, write_blobs)
     statement.write(bytes);
 
     ASSERT_THAT(readStatement.template optionalValue<Sqlite::Blob>(),
-                Optional(Field(&Sqlite::Blob::bytes, Eq(bytes))));
+                Optional(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, Eq(bytes))));
 }
 
 TEST_F(SqliteStatement, cannot_write_to_closed_database)
@@ -1145,7 +1145,7 @@ TEST_F(SqliteStatement, get_blob_values)
 
     auto values = statement.values<Sqlite::Blob>();
 
-    ASSERT_THAT(values, ElementsAre(Field(&Sqlite::Blob::bytes, Eq(bytes))));
+    ASSERT_THAT(values, ElementsAre(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, Eq(bytes))));
 }
 
 TEST_F(SqliteStatement, get_empty_optional_blob_value_for_integer)
@@ -1154,7 +1154,7 @@ TEST_F(SqliteStatement, get_empty_optional_blob_value_for_integer)
 
     auto value = statement.optionalValue<Sqlite::Blob>();
 
-    ASSERT_THAT(value, Optional(Field(&Sqlite::Blob::bytes, IsEmpty())));
+    ASSERT_THAT(value, Optional(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, IsEmpty())));
 }
 
 TEST_F(SqliteStatement, get_empty_optional_blob_value_for_float)
@@ -1163,7 +1163,7 @@ TEST_F(SqliteStatement, get_empty_optional_blob_value_for_float)
 
     auto value = statement.optionalValue<Sqlite::Blob>();
 
-    ASSERT_THAT(value, Optional(Field(&Sqlite::Blob::bytes, IsEmpty())));
+    ASSERT_THAT(value, Optional(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, IsEmpty())));
 }
 
 TEST_F(SqliteStatement, get_empty_optional_blob_value_for_text)
@@ -1172,7 +1172,7 @@ TEST_F(SqliteStatement, get_empty_optional_blob_value_for_text)
 
     auto value = statement.optionalValue<Sqlite::Blob>();
 
-    ASSERT_THAT(value, Optional(Field(&Sqlite::Blob::bytes, IsEmpty())));
+    ASSERT_THAT(value, Optional(Field("Sqlite::Blob::bytes", &Sqlite::Blob::bytes, IsEmpty())));
 }
 
 TEST_F(SqliteStatement, get_optional_single_value_and_multiple_query_value)
diff --git a/tests/unit/tests/unittests/sqlite/sqlitetable-test.cpp b/tests/unit/tests/unittests/sqlite/sqlitetable-test.cpp
index c71cf54ba4e..8e5b13550b8 100644
--- a/tests/unit/tests/unittests/sqlite/sqlitetable-test.cpp
+++ b/tests/unit/tests/unittests/sqlite/sqlitetable-test.cpp
@@ -172,10 +172,10 @@ TEST_F(SqliteTable, add_column)
     auto &column = table.addColumn("name", ColumnType::Text, {Sqlite::Unique{}});
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, ColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, ColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<Sqlite::Unique>(Eq(Sqlite::Unique{}))))));
 }
 
@@ -193,16 +193,16 @@ TEST_F(SqliteTable, add_foreign_key_column_with_table)
                                              Enforment::Deferred);
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, ColumnType::Integer),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, ColumnType::Integer),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                      Field(&ForeignKey::column, IsEmpty()),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, IsEmpty()),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 TEST_F(SqliteTable, add_foreign_key_column_with_column)
@@ -219,16 +219,16 @@ TEST_F(SqliteTable, add_foreign_key_column_with_column)
                                              Enforment::Deferred);
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, ColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, ColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                      Field(&ForeignKey::column, Eq("foreignColumn")),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, Eq("foreignColumn")),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 TEST_F(SqliteTable, add_foreign_key_which_is_not_unique_throws_an_exceptions)
@@ -261,17 +261,17 @@ TEST_F(SqliteTable, add_foreign_key_column_with_table_and_not_null)
                                              {Sqlite::NotNull{}});
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, ColumnType::Integer),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, ColumnType::Integer),
+                      Field("Column::constraints", &Column::constraints,
                             UnorderedElementsAre(
                                 VariantWith<ForeignKey>(
-                                    AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                          Field(&ForeignKey::column, IsEmpty()),
-                                          Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                          Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                          Field(&ForeignKey::enforcement, Enforment::Deferred))),
+                                    AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                          Field("ForeignKey::column", &ForeignKey::column, IsEmpty()),
+                                          Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                          Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                          Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred))),
                                 VariantWith<Sqlite::NotNull>(Eq(Sqlite::NotNull{}))))));
 }
 
@@ -290,17 +290,17 @@ TEST_F(SqliteTable, add_foreign_key_column_with_column_and_not_null)
                                              {Sqlite::NotNull{}});
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, ColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, ColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             UnorderedElementsAre(
                                 VariantWith<ForeignKey>(
-                                    AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                          Field(&ForeignKey::column, Eq("foreignColumn")),
-                                          Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                          Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                          Field(&ForeignKey::enforcement, Enforment::Deferred))),
+                                    AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                          Field("ForeignKey::column", &ForeignKey::column, Eq("foreignColumn")),
+                                          Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                          Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                          Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred))),
                                 VariantWith<Sqlite::NotNull>(Eq(Sqlite::NotNull{}))))));
 }
 
@@ -471,10 +471,10 @@ TEST_F(StrictSqliteTable, add_column)
     auto &column = table.addColumn("name", StrictColumnType::Text, {Sqlite::Unique{}});
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, StrictColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, StrictColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<Sqlite::Unique>(Eq(Sqlite::Unique{}))))));
 }
 
@@ -492,16 +492,16 @@ TEST_F(StrictSqliteTable, add_foreign_key_column_with_table)
                                              Enforment::Deferred);
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, StrictColumnType::Integer),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, StrictColumnType::Integer),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                      Field(&ForeignKey::column, IsEmpty()),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, IsEmpty()),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 TEST_F(StrictSqliteTable, add_foreign_key_column_with_column)
@@ -520,16 +520,16 @@ TEST_F(StrictSqliteTable, add_foreign_key_column_with_column)
                                              Enforment::Deferred);
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, StrictColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, StrictColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             ElementsAre(VariantWith<ForeignKey>(
-                                AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                      Field(&ForeignKey::column, Eq("foreignColumn")),
-                                      Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                      Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                      Field(&ForeignKey::enforcement, Enforment::Deferred)))))));
+                                AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                      Field("ForeignKey::column", &ForeignKey::column, Eq("foreignColumn")),
+                                      Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                      Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                      Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred)))))));
 }
 
 TEST_F(StrictSqliteTable, add_foreign_key_which_is_not_unique_throws_an_exceptions)
@@ -562,17 +562,17 @@ TEST_F(StrictSqliteTable, add_foreign_key_column_with_table_and_not_null)
                                              {Sqlite::NotNull{}});
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, StrictColumnType::Integer),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, StrictColumnType::Integer),
+                      Field("Column::constraints", &Column::constraints,
                             UnorderedElementsAre(
                                 VariantWith<ForeignKey>(
-                                    AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                          Field(&ForeignKey::column, IsEmpty()),
-                                          Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                          Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                          Field(&ForeignKey::enforcement, Enforment::Deferred))),
+                                    AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                          Field("ForeignKey::column", &ForeignKey::column, IsEmpty()),
+                                          Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                          Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                          Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred))),
                                 VariantWith<Sqlite::NotNull>(Eq(Sqlite::NotNull{}))))));
 }
 
@@ -593,17 +593,17 @@ TEST_F(StrictSqliteTable, add_foreign_key_column_with_column_and_not_null)
                                              {Sqlite::NotNull{}});
 
     ASSERT_THAT(column,
-                AllOf(Field(&Column::name, Eq("name")),
-                      Field(&Column::tableName, Eq(tableName)),
-                      Field(&Column::type, StrictColumnType::Text),
-                      Field(&Column::constraints,
+                AllOf(Field("Column::name", &Column::name, Eq("name")),
+                      Field("Column::tableName", &Column::tableName, Eq(tableName)),
+                      Field("Column::type", &Column::type, StrictColumnType::Text),
+                      Field("Column::constraints", &Column::constraints,
                             UnorderedElementsAre(
                                 VariantWith<ForeignKey>(
-                                    AllOf(Field(&ForeignKey::table, Eq("foreignTable")),
-                                          Field(&ForeignKey::column, Eq("foreignColumn")),
-                                          Field(&ForeignKey::updateAction, ForeignKeyAction::SetNull),
-                                          Field(&ForeignKey::deleteAction, ForeignKeyAction::Cascade),
-                                          Field(&ForeignKey::enforcement, Enforment::Deferred))),
+                                    AllOf(Field("ForeignKey::table", &ForeignKey::table, Eq("foreignTable")),
+                                          Field("ForeignKey::column", &ForeignKey::column, Eq("foreignColumn")),
+                                          Field("ForeignKey::updateAction", &ForeignKey::updateAction, ForeignKeyAction::SetNull),
+                                          Field("ForeignKey::deleteAction", &ForeignKey::deleteAction, ForeignKeyAction::Cascade),
+                                          Field("ForeignKey::enforcement", &ForeignKey::enforcement, Enforment::Deferred))),
                                 VariantWith<Sqlite::NotNull>(Eq(Sqlite::NotNull{}))))));
 }