QmlDesigner: Add type lookup

Task-number: QDS-10246
Change-Id: I607f72e29734a3c59b7b5b33d96735d708cd18ec
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

src/plugins/qmldesigner/CMakeLists.txt

@@ -407,7 +407,7 @@ extend_qtc_library(QmlDesignerCore
     projectstorage.cpp projectstorage.h
     sourcepath.h
     sourcepathcache.h
-    sourcepathcache.h
+    sourcepathcacheinterface.h
     sourcepathcachetypes.h
     sourcepathview.h
     storagecache.h

src/plugins/qmldesigner/components/integration/designdocument.cpp

@@ -61,7 +61,7 @@ namespace QmlDesigner {
   DesignDocument acts as a facade to a model representing a qml document,
   and the different views/widgets accessing it.
   */
-DesignDocument::DesignDocument(ProjectStorage<Sqlite::Database> &projectStorage,
+DesignDocument::DesignDocument(ProjectStorageDependencies projectStorageDependencies,
                                ExternalDependenciesInterface &externalDependencies)
     : m_documentModel(
         Model::create("QtQuick.Item", 1, 0, nullptr, std::make_unique<ModelResourceManagement>()))
@@ -69,7 +69,7 @@ DesignDocument::DesignDocument(ProjectStorage<Sqlite::Database> &projectStorage,
     , m_rewriterView(new RewriterView(externalDependencies, RewriterView::Amend))
     , m_documentLoaded(false)
     , m_currentTarget(nullptr)
-    , m_projectStorage(projectStorage)
+    , m_projectStorageDependencies(projectStorageDependencies)
     , m_externalDependencies{externalDependencies}
 {
 }

src/plugins/qmldesigner/components/integration/designdocument.h

@@ -39,7 +39,7 @@ class QMLDESIGNERCOMPONENTS_EXPORT DesignDocument : public QObject
     Q_OBJECT
 
 public:
-    DesignDocument(ProjectStorage<Sqlite::Database> &projectStorage,
+    DesignDocument(ProjectStorageDependencies projectStorageDependencies,
                    ExternalDependenciesInterface &externalDependencies);
     ~DesignDocument() override;
 
@@ -143,7 +143,7 @@ private: // variables
     QScopedPointer<RewriterView> m_rewriterView;
     bool m_documentLoaded;
     ProjectExplorer::Target *m_currentTarget;
-    ProjectStorage<Sqlite::Database> &m_projectStorage;
+    ProjectStorageDependencies m_projectStorageDependencies;
     ExternalDependenciesInterface &m_externalDependencies;
 };
 

src/plugins/qmldesigner/components/itemlibrary/itemlibraryview.cpp

@@ -62,7 +62,7 @@ void ItemLibraryView::modelAttached(Model *model)
     m_widget->setModel(model);
     updateImports();
     if (model)
-        m_widget->updatePossibleImports(difference(model->possibleImports(), model->imports()));
+        m_widget->updatePossibleImports(set_difference(model->possibleImports(), model->imports()));
     m_hasErrors = !rewriterView()->errors().isEmpty();
     m_widget->setFlowMode(QmlItemNode(rootModelNode()).isFlowView());
 }

src/plugins/qmldesigner/components/itemlibrary/itemlibrarywidget.cpp

@@ -338,7 +338,7 @@ void ItemLibraryWidget::updateModel()
 
 void ItemLibraryWidget::updatePossibleImports(const Imports &possibleImports)
 {
-    m_addModuleModel->update(difference(possibleImports, m_model->imports()));
+    m_addModuleModel->update(set_difference(possibleImports, m_model->imports()));
     delayedUpdateModel();
 }
 
@@ -358,7 +358,7 @@ void ItemLibraryWidget::handlePriorityImportsChanged()
 {
     if (!m_itemLibraryInfo.isNull()) {
         m_addModuleModel->setPriorityImports(m_itemLibraryInfo->priorityImports());
-        m_addModuleModel->update(difference(m_model->possibleImports(), m_model->imports()));
+        m_addModuleModel->update(set_difference(m_model->possibleImports(), m_model->imports()));
     }
 }
 

src/plugins/qmldesigner/designercore/include/import.h

@@ -44,6 +44,11 @@ public:
 
 class QMLDESIGNERCORE_EXPORT Import
 {
+    using Imports = QList<Import>;
+    QMLDESIGNERCORE_EXPORT friend Imports set_strict_difference(const Imports &first,
+                                                                const Imports &second);
+    enum class Type { Empty, Library, File };
+
 public:
     Import() = default;
 
@@ -51,14 +56,14 @@ public:
     static Import createFileImport(const QString &file, const QString &version = QString(), const QString &alias = QString(), const QStringList &importPaths = QStringList());
     static Import empty();
 
-    bool isEmpty() const { return m_url.isEmpty() && m_file.isEmpty(); }
-    bool isFileImport() const { return m_url.isEmpty() && !m_file.isEmpty(); }
-    bool isLibraryImport() const { return !m_url.isEmpty() && m_file.isEmpty(); }
+    bool isEmpty() const { return m_type == Type::Empty; }
+    bool isFileImport() const { return m_type == Type::File; }
+    bool isLibraryImport() const { return m_type == Type::Library; }
     bool hasVersion() const { return !m_version.isEmpty(); }
     bool hasAlias() const { return !m_alias.isEmpty(); }
 
-    const QString &url() const { return m_url; }
-    const QString &file() const { return m_file; }
+    const QString &url() const { return m_type == Type::Library ? m_url : emptyString; }
+    const QString &file() const { return m_type == Type::File ? m_url : emptyString; }
     const QString &version() const { return m_version; }
     const QString &alias() const { return m_alias; }
     const QStringList &importPaths() const { return m_importPathList; }
@@ -76,32 +81,40 @@ public:
 
     friend bool operator==(const Import &first, const Import &second)
     {
-        return first.m_url == second.m_url && first.m_file == second.m_file
+        return first.m_url == second.m_url && first.m_type == second.m_type
                && (first.m_version == second.m_version || first.m_version.isEmpty()
                    || second.m_version.isEmpty());
     }
 
     friend bool operator<(const Import &first, const Import &second)
     {
-        return std::tie(first.m_url, first.m_file) < std::tie(second.m_url, second.m_file);
+        return std::tie(first.m_url, first.m_type) < std::tie(second.m_url, second.m_type);
     }
 
 private:
-    Import(const QString &url, const QString &file, const QString &version, const QString &alias, const QStringList &importPaths);
+    Import(const QString &url,
+           const QString &version,
+           const QString &alias,
+           const QStringList &importPaths,
+           Type type);
 
 private:
+    inline static const QString emptyString;
     QString m_url;
-    QString m_file;
     QString m_version;
     QString m_alias;
     QStringList m_importPathList;
+    Type m_type = Type::Empty;
 };
 
 QMLDESIGNERCORE_EXPORT size_t qHash(const Import &import);
 
 using Imports = QList<Import>;
 
-QMLDESIGNERCORE_EXPORT Imports difference(const Imports &first, const Imports &second);
+QMLDESIGNERCORE_EXPORT Imports set_difference(const Imports &first, const Imports &second);
+QMLDESIGNERCORE_EXPORT Imports set_stict_difference(const Imports &first, const Imports &second);
+QMLDESIGNERCORE_EXPORT Imports set_union(const Imports &first, const Imports &second);
+QMLDESIGNERCORE_EXPORT Imports set_intersection(const Imports &first, const Imports &second);
 
 template<typename Callable>
 void differenceCall(const Imports &first, const Imports &second, Callable callable)

src/plugins/qmldesigner/designercore/include/model.h

@@ -62,12 +62,16 @@ class QMLDESIGNERCORE_EXPORT Model : public QObject
 public:
     enum ViewNotification { NotifyView, DoNotNotifyView };
 
-    Model(ProjectStorageType &projectStorage,
+    Model(ProjectStorageDependencies projectStorageDependencies,
           const TypeName &type,
           int major = 1,
           int minor = 1,
           Model *metaInfoProxyModel = nullptr,
           std::unique_ptr<ModelResourceManagementInterface> resourceManagement = {});
+    Model(ProjectStorageDependencies projectStorageDependencies,
+          Utils::SmallStringView typeName,
+          Imports imports,
+          const QUrl &fileUrl);
     Model(const TypeName &typeName,
           int major = 1,
           int minor = 1,
@@ -86,14 +90,25 @@ public:
             new Model(typeName, major, minor, metaInfoProxyModel, std::move(resourceManagement)));
     }
 
-    static ModelPointer create(ProjectStorageType &projectStorage,
+    static ModelPointer create(ProjectStorageDependencies projectStorageDependencies,
+                               Utils::SmallStringView typeName,
+                               Imports imports,
+                               const QUrl &fileUrl)
+    {
+        return ModelPointer(new Model(projectStorageDependencies, typeName, imports, fileUrl));
+    }
+    static ModelPointer create(ProjectStorageDependencies m_projectStorageDependencies,
                                const TypeName &typeName,
                                int major = 1,
                                int minor = 1,
                                std::unique_ptr<ModelResourceManagementInterface> resourceManagement = {})
     {
-        return ModelPointer(
-            new Model(projectStorage, typeName, major, minor, nullptr, std::move(resourceManagement)));
+        return ModelPointer(new Model(m_projectStorageDependencies,
+                                      typeName,
+                                      major,
+                                      minor,
+                                      nullptr,
+                                      std::move(resourceManagement)));
     }
 
     QUrl fileUrl() const;
@@ -111,6 +126,8 @@ public:
     NodeMetaInfo flowViewFlowTransitionMetaInfo() const;
     NodeMetaInfo flowViewFlowWildcardMetaInfo() const;
     NodeMetaInfo fontMetaInfo() const;
+    NodeMetaInfo qmlQtObjectMetaInfo() const;
+    NodeMetaInfo qtQmlModelsListModelMetaInfo() const;
     NodeMetaInfo qtQuick3DBakedLightmapMetaInfo() const;
     NodeMetaInfo qtQuick3DDefaultMaterialMetaInfo() const;
     NodeMetaInfo qtQuick3DMaterialMetaInfo() const;
@@ -145,6 +162,7 @@ public:
     QHash<QStringView, ModelNode> idModelNodeDict();
 
     ModelNode createModelNode(const TypeName &typeName);
+    void changeRootNodeType(const TypeName &type);
 
     void removeModelNodes(ModelNodes nodes,
                           BypassModelResourceManagement = BypassModelResourceManagement::No);
@@ -157,7 +175,7 @@ public:
     const Imports &imports() const;
     const Imports &possibleImports() const;
     const Imports &usedImports() const;
-    void changeImports(const Imports &importsToBeAdded, const Imports &importsToBeRemoved);
+    void changeImports(Imports importsToBeAdded, Imports importsToBeRemoved);
     void setPossibleImports(Imports possibleImports);
     void setUsedImports(Imports usedImports);
     bool hasImport(const Import &import, bool ignoreAlias = true, bool allowHigherVersion = false) const;

src/plugins/qmldesigner/designercore/include/modelfwd.h

@@ -16,6 +16,9 @@ using PropertyTypeList = QList<PropertyName>;
 using IdName = QByteArray;
 class Model;
 class ModelNode;
+class NonLockingMutex;
+template<typename ProjectStorage, typename Mutex = NonLockingMutex>
+class SourcePathCache;
 
 struct ModelDeleter
 {
@@ -35,10 +38,18 @@ constexpr bool useProjectStorage()
 
 #ifdef QDS_MODEL_USE_PROJECTSTORAGEINTERFACE
 using ProjectStorageType = ProjectStorageInterface;
+using PathCacheType = SourcePathCacheInterface;
 #else
 using ProjectStorageType = ProjectStorage<Sqlite::Database>;
+using PathCacheType = SourcePathCache<ProjectStorageType, NonLockingMutex>;
 #endif
 
+struct ProjectStorageDependencies
+{
+    ProjectStorageType &storage;
+    PathCacheType &cache;
+};
+
 enum class PropertyType {
     None,
     Variant,

src/plugins/qmldesigner/designercore/include/projectstorageids.h

@@ -5,6 +5,8 @@
 
 #include <sqlite/sqliteids.h>
 
+#include <utils/span.h>
+
 namespace QmlDesigner {
 
 enum class BasicIdType {
@@ -48,6 +50,7 @@ using SourceIds = std::vector<SourceId>;
 
 using ModuleId = Sqlite::BasicId<BasicIdType::Module, int>;
 using ModuleIds = std::vector<ModuleId>;
+using ModuleIdSpan = Utils::span<ModuleId>;
 
 using ProjectPartId = Sqlite::BasicId<BasicIdType::ProjectPartId>;
 using ProjectPartIds = std::vector<ProjectPartId>;

src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp

@@ -1568,7 +1568,7 @@ PropertyMetaInfo NodeMetaInfo::defaultProperty() const
 bool NodeMetaInfo::hasDefaultProperty() const
 {
     if constexpr (useProjectStorage())
-        return bool(typeData().defaultPropertyId);
+        return isValid() && bool(typeData().defaultPropertyId);
     else
         return !defaultPropertyName().isEmpty();
 }

src/plugins/qmldesigner/designercore/model/import.cpp

@@ -11,17 +11,17 @@ namespace QmlDesigner {
 
 Import Import::createLibraryImport(const QString &url, const QString &version, const QString &alias, const QStringList &importPaths)
 {
-    return Import(url, QString(), version, alias, importPaths);
+    return Import(url, version, alias, importPaths, Type::Library);
 }
 
 Import Import::createFileImport(const QString &file, const QString &version, const QString &alias, const QStringList &importPaths)
 {
-    return Import(QString(), file, version, alias, importPaths);
+    return Import(file, version, alias, importPaths, Type::File);
 }
 
 Import Import::empty()
 {
-    return Import(QString(), QString(), QString(), QString(), QStringList());
+    return Import(QString(), QString(), QString(), QStringList(), Type::Empty);
 }
 
 QString Import::toImportString() const
@@ -33,12 +33,16 @@ QString Import::toImportString() const
     return result;
 }
 
-Import::Import(const QString &url, const QString &file, const QString &version, const QString &alias, const QStringList &importPaths):
-        m_url(url),
-        m_file(file),
-        m_version(version),
-        m_alias(alias),
-        m_importPathList(importPaths)
+Import::Import(const QString &url,
+               const QString &version,
+               const QString &alias,
+               const QStringList &importPaths,
+               Type type)
+    : m_url(url)
+    , m_version(version)
+    , m_alias(alias)
+    , m_importPathList(importPaths)
+    , m_type(type)
 {
 }
 
@@ -137,7 +141,7 @@ size_t qHash(const Import &import)
     return ::qHash(import.url()) ^ ::qHash(import.file()) ^ ::qHash(import.version()) ^ ::qHash(import.alias());
 }
 
-Imports difference(const Imports &first, const Imports &second)
+Imports set_difference(const Imports &first, const Imports &second)
 {
     Imports difference;
     difference.reserve(first.size());
@@ -150,4 +154,53 @@ Imports difference(const Imports &first, const Imports &second)
 
     return difference;
 }
+
+Imports set_union(const Imports &first, const Imports &second)
+{
+    Imports set_union;
+    set_union.reserve(std::min(first.size(), second.size()));
+
+    std::set_union(first.begin(),
+                   first.end(),
+                   second.begin(),
+                   second.end(),
+                   std::back_inserter(set_union));
+
+    return set_union;
+}
+
+Imports set_intersection(const Imports &first, const Imports &second)
+{
+    Imports set_intersection;
+    set_intersection.reserve(std::min(first.size(), second.size()));
+
+    std::set_intersection(first.begin(),
+                          first.end(),
+                          second.begin(),
+                          second.end(),
+                          std::back_inserter(set_intersection));
+
+    return set_intersection;
+}
+
+Imports set_strict_difference(const Imports &first, const Imports &second)
+{
+    Imports difference;
+    difference.reserve(first.size());
+
+    auto strictLess = [](const Import &first, const Import &second) {
+        return std::tie(first.m_url, first.m_type, first.m_version)
+               < std::tie(second.m_url, second.m_type, second.m_version);
+    };
+
+    std::set_difference(first.begin(),
+                        first.end(),
+                        second.begin(),
+                        second.end(),
+                        std::back_inserter(difference),
+                        strictLess);
+
+    return difference;
+}
+
 } // namespace QmlDesigner

src/plugins/qmldesigner/designercore/model/internalnode_p.h

@@ -199,8 +199,8 @@ public:
     int nodeSourceType = 0;
     QString behaviorPropertyName;
     QStringList scriptFunctions;
-    ModuleId moduleId;                   // is invalid if type is implicit
-    Utils::SmallString documentTypeName; // how the type is written in den Document
+    ModuleId moduleId;
+    ImportedTypeNameId importedTypeNameId;
     TypeId typeId;
 
 private:

src/plugins/qmldesigner/designercore/model/model.cpp

@@ -6,6 +6,8 @@
 #include "model_p.h"
 #include <modelnode.h>
 
+#include "../projectstorage/sourcepath.h"
+#include "../projectstorage/sourcepathcache.h"
 #include "abstractview.h"
 #include "auxiliarydataproperties.h"
 #include "internalbindingproperty.h"
@@ -60,18 +62,21 @@ namespace QmlDesigner {
 namespace Internal {
 
 ModelPrivate::ModelPrivate(Model *model,
-                           ProjectStorageType &projectStorage,
+                           ProjectStorageDependencies projectStorageDependencies,
                            const TypeName &typeName,
                            int major,
                            int minor,
                            Model *metaInfoProxyModel,
                            std::unique_ptr<ModelResourceManagementInterface> resourceManagement)
-    : projectStorage{&projectStorage}
+    : projectStorage{&projectStorageDependencies.storage}
+    , pathCache{&projectStorageDependencies.cache}
     , m_model{model}
     , m_resourceManagement{std::move(resourceManagement)}
 {
     m_metaInfoProxyModel = metaInfoProxyModel;
 
+    changeImports({Import::createLibraryImport({"QtQuick"})}, {});
+
     m_rootInternalNode = createNode(
         typeName, major, minor, {}, {}, {}, ModelNode::NodeWithoutSource, {}, true);
 
@@ -79,6 +84,25 @@ ModelPrivate::ModelPrivate(Model *model,
     m_currentTimelineNode = m_rootInternalNode;
 }
 
+ModelPrivate::ModelPrivate(Model *model,
+                           ProjectStorageDependencies projectStorageDependencies,
+                           Utils::SmallStringView typeName,
+                           Imports imports,
+                           const QUrl &fileUrl)
+    : projectStorage{&projectStorageDependencies.storage}
+    , pathCache{&projectStorageDependencies.cache}
+    , m_model{model}
+{
+    setFileUrl(fileUrl);
+    changeImports(std::move(imports), {});
+
+    m_rootInternalNode = createNode(
+        TypeName{typeName}, -1, -1, {}, {}, {}, ModelNode::NodeWithoutSource, {}, true);
+
+    m_currentStateNode = m_rootInternalNode;
+    m_currentTimelineNode = m_rootInternalNode;
+}
+
 ModelPrivate::ModelPrivate(Model *model,
                            const TypeName &typeName,
                            int major,
@@ -117,29 +141,41 @@ void ModelPrivate::detachAllViews()
     }
 }
 
-void ModelPrivate::changeImports(const Imports &toBeAddedImportList,
-                                 const Imports &toBeRemovedImportList)
+namespace {
+Storage::Imports createStorageImports(const Imports &imports,
+                                      ProjectStorageType &projectStorage,
+                                      SourceId fileId)
 {
-    Imports removedImportList;
-    for (const Import &import : toBeRemovedImportList) {
-        if (m_imports.contains(import)) {
-            removedImportList.append(import);
-            m_imports.removeOne(import);
+    return Utils::transform<Storage::Imports>(imports, [&](const Import &import) {
+        return Storage::Import{projectStorage.moduleId(Utils::SmallString{import.url()}),
+                               import.majorVersion(),
+                               import.minorVersion(),
+                               fileId};
+    });
+}
+
+} // namespace
+
+void ModelPrivate::changeImports(Imports toBeAddedImports, Imports toBeRemovedImports)
+{
+    std::sort(toBeAddedImports.begin(), toBeAddedImports.end());
+    std::sort(toBeRemovedImports.begin(), toBeRemovedImports.end());
+
+    Imports removedImports = set_intersection(m_imports, toBeRemovedImports);
+    m_imports = set_difference(m_imports, removedImports);
+
+    Imports allNewAddedImports = set_strict_difference(toBeAddedImports, m_imports);
+    Imports importWithoutAddedImport = set_difference(m_imports, allNewAddedImports);
+
+    m_imports = set_union(importWithoutAddedImport, allNewAddedImports);
+
+    if (!removedImports.isEmpty() || !allNewAddedImports.isEmpty()) {
+        if (useProjectStorage()) {
+            auto imports = createStorageImports(m_imports, *projectStorage, m_sourceId);
+            projectStorage->synchronizeDocumentImports(std::move(imports), m_sourceId);
         }
+        notifyImportsChanged(allNewAddedImports, removedImports);
     }
-
-    Imports addedImportList;
-    for (const Import &import : toBeAddedImportList) {
-        if (!m_imports.contains(import)) {
-            addedImportList.append(import);
-            m_imports.append(import);
-        }
-    }
-
-    std::sort(m_imports.begin(), m_imports.end());
-
-    if (!removedImportList.isEmpty() || !addedImportList.isEmpty())
-        notifyImportsChanged(addedImportList, removedImportList);
 }
 
 void ModelPrivate::notifyImportsChanged(const Imports &addedImports, const Imports &removedImports)
@@ -201,6 +237,9 @@ void ModelPrivate::setFileUrl(const QUrl &fileUrl)
 
     if (oldPath != fileUrl) {
         m_fileUrl = fileUrl;
+        if constexpr (useProjectStorage()) {
+            m_sourceId = pathCache->sourceId(SourcePath{fileUrl.path()});
+        }
 
         for (const QPointer<AbstractView> &view : std::as_const(m_viewList))
             view->fileUrlChanged(oldPath, fileUrl);
@@ -220,23 +259,6 @@ void ModelPrivate::changeNodeType(const InternalNodePointer &node, const TypeNam
     }
 }
 
-namespace {
-QT_WARNING_PUSH
-QT_WARNING_DISABLE_CLANG("-Wunneeded-internal-declaration")
-
-std::pair<Utils::SmallStringView, Utils::SmallStringView> decomposeTypePath(Utils::SmallStringView typeName)
-{
-    auto found = std::find(typeName.rbegin(), typeName.rend(), '.');
-
-    if (found == typeName.rend())
-        return {};
-
-    return {{typeName.begin(), std::prev(found.base())}, {found.base(), typeName.end()}};
-}
-
-QT_WARNING_POP
-} // namespace
-
 InternalNodePointer ModelPrivate::createNode(const TypeName &typeName,
                                              int majorVersion,
                                              int minorVersion,
@@ -257,13 +279,7 @@ InternalNodePointer ModelPrivate::createNode(const TypeName &typeName,
 
     auto newNode = std::make_shared<InternalNode>(typeName, majorVersion, minorVersion, internalId);
 
-    if constexpr (useProjectStorage()) {
-        auto [moduleName, shortTypeName] = decomposeTypePath(typeName);
-        ModuleId moduleId = projectStorage->moduleId(moduleName);
-        newNode->typeId = projectStorage->typeId(moduleId,
-                                                 shortTypeName,
-                                                 Storage::Version{majorVersion, minorVersion});
-    }
+    setTypeId(newNode.get(), typeName);
 
     newNode->nodeSourceType = nodeSourceType;
 
@@ -314,6 +330,49 @@ EnabledViewRange ModelPrivate::enabledViews() const
     return EnabledViewRange{m_viewList};
 }
 
+namespace {
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_CLANG("-Wunneeded-internal-declaration")
+
+std::pair<Utils::SmallStringView, Utils::SmallStringView> decomposeTypePath(Utils::SmallStringView typeName)
+{
+    auto found = std::find(typeName.rbegin(), typeName.rend(), '.');
+
+    if (found == typeName.rend())
+        return {{}, typeName};
+
+    return {{typeName.begin(), std::prev(found.base())}, {found.base(), typeName.end()}};
+}
+
+QT_WARNING_POP
+} // namespace
+
+void ModelPrivate::setTypeId(InternalNode *node, Utils::SmallStringView typeName)
+{
+    if constexpr (useProjectStorage()) {
+        auto [moduleName, shortTypeName] = decomposeTypePath(typeName);
+
+        if (moduleName.size()) {
+            QString aliasName = QString{moduleName};
+            auto found = std::find_if(m_imports.begin(), m_imports.end(), [&](const Import &import) {
+                return import.alias() == aliasName;
+            });
+            if (found != m_imports.end()) {
+                ModuleId moduleId = projectStorage->moduleId(Utils::PathString{found->url()});
+                ImportId importId = projectStorage->importId(
+                    Storage::Import{moduleId, found->majorVersion(), found->minorVersion(), m_sourceId});
+                ImportedTypeNameId typeNameId = projectStorage->importedTypeNameId(importId,
+                                                                                   shortTypeName);
+                node->typeId = projectStorage->typeId(typeNameId);
+                return;
+            }
+        }
+
+        ImportedTypeNameId typeNameId = projectStorage->importedTypeNameId(m_sourceId, shortTypeName);
+        node->typeId = projectStorage->typeId(typeNameId);
+    }
+}
+
 void ModelPrivate::handleResourceSet(const ModelResourceSet &resourceSet)
 {
     for (const ModelNode &node : resourceSet.removeModelNodes) {
@@ -1343,9 +1402,11 @@ void ModelPrivate::clearParent(const InternalNodePointer &node)
 void ModelPrivate::changeRootNodeType(const TypeName &type, int majorVersion, int minorVersion)
 {
     Q_ASSERT(rootNode());
-    rootNode()->typeName = type;
-    rootNode()->majorVersion = majorVersion;
-    rootNode()->minorVersion = minorVersion;
+
+    m_rootInternalNode->typeName = type;
+    m_rootInternalNode->majorVersion = majorVersion;
+    m_rootInternalNode->minorVersion = minorVersion;
+    setTypeId(m_rootInternalNode.get(), type);
     notifyRootNodeTypeChanged(QString::fromUtf8(type), majorVersion, minorVersion);
 }
 
@@ -1512,14 +1573,27 @@ void WriteLocker::lock(Model *model)
 
 } // namespace Internal
 
-Model::Model(ProjectStorageType &projectStorage,
+Model::Model(ProjectStorageDependencies projectStorageDependencies,
              const TypeName &typeName,
              int major,
              int minor,
              Model *metaInfoProxyModel,
              std::unique_ptr<ModelResourceManagementInterface> resourceManagement)
+    : d(std::make_unique<Internal::ModelPrivate>(this,
+                                                 projectStorageDependencies,
+                                                 typeName,
+                                                 major,
+                                                 minor,
+                                                 metaInfoProxyModel,
+                                                 std::move(resourceManagement)))
+{}
+
+Model::Model(ProjectStorageDependencies projectStorageDependencies,
+             Utils::SmallStringView typeName,
+             Imports imports,
+             const QUrl &fileUrl)
     : d(std::make_unique<Internal::ModelPrivate>(
-        this, projectStorage, typeName, major, minor, metaInfoProxyModel, std::move(resourceManagement)))
+        this, projectStorageDependencies, typeName, std::move(imports), fileUrl))
 {}
 
 Model::Model(const TypeName &typeName,
@@ -1548,9 +1622,9 @@ const Imports &Model::usedImports() const
     return d->m_usedImportList;
 }
 
-void Model::changeImports(const Imports &importsToBeAdded, const Imports &importsToBeRemoved)
+void Model::changeImports(Imports importsToBeAdded, Imports importsToBeRemoved)
 {
-    d->changeImports(importsToBeAdded, importsToBeRemoved);
+    d->changeImports(std::move(importsToBeAdded), std::move(importsToBeRemoved));
 }
 
 void Model::setPossibleImports(Imports possibleImports)
@@ -1927,6 +2001,26 @@ NodeMetaInfo Model::fontMetaInfo() const
     }
 }
 
+NodeMetaInfo Model::qtQmlModelsListModelMetaInfo() const
+{
+    if constexpr (useProjectStorage()) {
+        using namespace Storage::Info;
+        return createNodeMetaInfo<QtQml_Models, ListModel>();
+    } else {
+        return metaInfo("QtQml.Models.ListModel");
+    }
+}
+
+NodeMetaInfo Model::qmlQtObjectMetaInfo() const
+{
+    if constexpr (useProjectStorage()) {
+        using namespace Storage::Info;
+        return createNodeMetaInfo<QML, QtObject>();
+    } else {
+        return metaInfo("QML.QtObject");
+    }
+}
+
 NodeMetaInfo Model::qtQuickItemMetaInfo() const
 {
     if constexpr (useProjectStorage()) {
@@ -2359,6 +2453,13 @@ ModelNode Model::createModelNode(const TypeName &typeName)
     }
 }
 
+void Model::changeRootNodeType(const TypeName &type)
+{
+    Internal::WriteLocker locker(this);
+
+    d->changeRootNodeType(type, -1, -1);
+}
+
 void Model::removeModelNodes(ModelNodes nodes, BypassModelResourceManagement bypass)
 {
     nodes.erase(std::remove_if(nodes.begin(), nodes.end(), [](auto &&node) { return !node; }),

src/plugins/qmldesigner/designercore/model/model_p.h

@@ -98,12 +98,17 @@ class ModelPrivate : public QObject
 
 public:
     ModelPrivate(Model *model,
-                 ProjectStorageType &projectStorage,
+                 ProjectStorageDependencies m_projectStorageDependencies,
                  const TypeName &type,
                  int major,
                  int minor,
                  Model *metaInfoProxyModel,
                  std::unique_ptr<ModelResourceManagementInterface> resourceManagement);
+    ModelPrivate(Model *model,
+                 ProjectStorageDependencies m_projectStorageDependencies,
+                 Utils::SmallStringView typeName,
+                 Imports imports,
+                 const QUrl &filePath);
     ModelPrivate(Model *model,
                  const TypeName &type,
                  int major,
@@ -235,7 +240,7 @@ public:
 
     // Imports:
     const Imports &imports() const { return m_imports; }
-    void changeImports(const Imports &importsToBeAdded, const Imports &importToBeRemoved);
+    void changeImports(Imports importsToBeAdded, Imports importToBeRemoved);
     void notifyImportsChanged(const Imports &addedImports, const Imports &removedImports);
     void notifyPossibleImportsChanged(const Imports &possibleImports);
     void notifyUsedImportsChanged(const Imports &usedImportsChanged);
@@ -306,9 +311,11 @@ private:
     static QList<std::tuple<InternalBindingPropertyPointer, QString>> toInternalBindingProperties(
         const ModelResourceSet::SetExpressions &setExpressions);
     EnabledViewRange enabledViews() const;
+    void setTypeId(InternalNode *node, Utils::SmallStringView typeName);
 
 public:
     NotNullPointer<ProjectStorageType> projectStorage = nullptr;
+    NotNullPointer<PathCacheType> pathCache = nullptr;
 
 private:
     Model *m_model = nullptr;
@@ -326,6 +333,7 @@ private:
     InternalNodePointer m_currentTimelineNode;
     std::unique_ptr<ModelResourceManagementInterface> m_resourceManagement;
     QUrl m_fileUrl;
+    SourceId m_sourceId;
     QPointer<RewriterView> m_rewriterView;
     QPointer<NodeInstanceView> m_nodeInstanceView;
     QPointer<Model> m_metaInfoProxyModel;

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

@@ -55,6 +55,7 @@ inline constexpr char Item[] = "Item";
 inline constexpr char KeyframeGroup[] = "KeyframeGroup";
 inline constexpr char Keyframe[] = "Keyframe";
 inline constexpr char Layout[] = "Layout";
+inline constexpr char ListModel[] = "ListModel";
 inline constexpr char ListView[] = "ListView";
 inline constexpr char Loader[] = "Loader";
 inline constexpr char Material[] = "Material";
@@ -80,6 +81,7 @@ inline constexpr char QQuickStateOperation[] = "QQuickStateOperation";
 inline constexpr char QtMultimedia[] = "QtMultimedia";
 inline constexpr char QtObject[] = "QtObject";
 inline constexpr char QtQml[] = "QtQml";
+inline constexpr char QtQml_Models[] = "QtQml.Models";
 inline constexpr char QtQuick3D[] = "QtQuick3D";
 inline constexpr char QtQuick3D_Particles3D[] = "QtQuick3D.Particles3D";
 inline constexpr char QtQuick3D_Particles3D_cppnative[] = "QtQuick3D.Particles3D-cppnative";
@@ -140,93 +142,95 @@ struct CacheType : public BaseCacheType
 template<typename ProjectStorage>
 class CommonTypeCache
 {
-    using CommonTypes = std::tuple<CacheType<FlowView, FlowActionArea>,
-                                   CacheType<FlowView, FlowDecision>,
-                                   CacheType<FlowView, FlowItem>,
-                                   CacheType<FlowView, FlowTransition>,
-                                   CacheType<FlowView, FlowView>,
-                                   CacheType<FlowView, FlowWildcard>,
-                                   CacheType<QML, BoolType>,
-                                   CacheType<QML, Component>,
-                                   CacheType<QML, DoubleType>,
-                                   CacheType<QML, IntType>,
-                                   CacheType<QML, QtObject>,
-                                   CacheType<QML, date>,
-                                   CacheType<QML, string>,
-                                   CacheType<QML, url>,
-                                   CacheType<QML, var>,
-                                   CacheType<QML_cppnative, FloatType>,
-                                   CacheType<QtMultimedia, SoundEffect>,
-                                   CacheType<QtQuick, BorderImage>,
-                                   CacheType<QtQuick, Connections>,
-                                   CacheType<QtQuick, GridView>,
-                                   CacheType<QtQuick, Image>,
-                                   CacheType<QtQuick, Item>,
-                                   CacheType<QtQuick, ListView>,
-                                   CacheType<QtQuick, Loader>,
-                                   CacheType<QtQuick, Path>,
-                                   CacheType<QtQuick, PathView>,
-                                   CacheType<QtQuick, PauseAnimation>,
-                                   CacheType<QtQuick, Positioner>,
-                                   CacheType<QtQuick, PropertyAnimation>,
-                                   CacheType<QtQuick, PropertyChanges>,
-                                   CacheType<QtQuick, Rectangle>,
-                                   CacheType<QtQuick, Repeater>,
-                                   CacheType<QtQuick, State>,
-                                   CacheType<QtQuick, StateGroup>,
-                                   CacheType<QtQuick, Text>,
-                                   CacheType<QtQuick, TextEdit>,
-                                   CacheType<QtQuick, Transition>,
-                                   CacheType<QtQuick, color>,
-                                   CacheType<QtQuick, font>,
-                                   CacheType<QtQuick, vector2d>,
-                                   CacheType<QtQuick, vector3d>,
-                                   CacheType<QtQuick, vector4d>,
-                                   CacheType<QtQuick3D, BakedLightmap>,
-                                   CacheType<QtQuick3D, Buffer>,
-                                   CacheType<QtQuick3D, Camera>,
-                                   CacheType<QtQuick3D, Command>,
-                                   CacheType<QtQuick3D, CubeMapTexture>,
-                                   CacheType<QtQuick3D, DefaultMaterial>,
-                                   CacheType<QtQuick3D, Effect>,
-                                   CacheType<QtQuick3D, InstanceList>,
-                                   CacheType<QtQuick3D, InstanceListEntry>,
-                                   CacheType<QtQuick3D, Light>,
-                                   CacheType<QtQuick3D, Material>,
-                                   CacheType<QtQuick3D, Model>,
-                                   CacheType<QtQuick3D, Node>,
-                                   CacheType<QtQuick3D, Pass>,
-                                   CacheType<QtQuick3D, PrincipledMaterial>,
-                                   CacheType<QtQuick3D, SceneEnvironment>,
-                                   CacheType<QtQuick3D, SpecularGlossyMaterial>,
-                                   CacheType<QtQuick3D, Shader>,
-                                   CacheType<QtQuick3D, Texture>,
-                                   CacheType<QtQuick3D, TextureInput>,
-                                   CacheType<QtQuick3D, View3D>,
-                                   CacheType<QtQuick3D_Particles3D, Affector3D>,
-                                   CacheType<QtQuick3D_Particles3D, Attractor3D>,
-                                   CacheType<QtQuick3D_Particles3D, Model>,
-                                   CacheType<QtQuick3D_Particles3D, Particle3D>,
-                                   CacheType<QtQuick3D_Particles3D, ParticleEmitter3D>,
-                                   CacheType<QtQuick3D_Particles3D, SpriteParticle3D>,
-                                   CacheType<QtQuick3D_Particles3D_cppnative, QQuick3DParticleAbstractShape>,
-                                   CacheType<QtQuick_Controls, Popup>,
-                                   CacheType<QtQuick_Controls, SplitView>,
-                                   CacheType<QtQuick_Controls, SwipeView>,
-                                   CacheType<QtQuick_Controls, TabBar>,
-                                   CacheType<QtQuick_Controls, TextArea>,
-                                   CacheType<QtQuick_Dialogs, Dialog>,
-                                   CacheType<QtQuick_Extras, Picture>,
-                                   CacheType<QtQuick_Layouts, Layout>,
-                                   CacheType<QtQuick_Studio_Components, GroupItem>,
-                                   CacheType<QtQuick_Timeline, Keyframe>,
-                                   CacheType<QtQuick_Timeline, KeyframeGroup>,
-                                   CacheType<QtQuick_Timeline, Timeline>,
-                                   CacheType<QtQuick_Timeline, TimelineAnimation>,
-                                   CacheType<QtQuick_cppnative, QQuickStateOperation>,
-                                   CacheType<Qt_SafeRenderer, SafePicture>,
-                                   CacheType<Qt_SafeRenderer, SafeRendererPicture>,
-                                   CacheType<QtQuick_Window, Window>>;
+    using CommonTypes
+        = std::tuple<CacheType<FlowView, FlowActionArea>,
+                     CacheType<FlowView, FlowDecision>,
+                     CacheType<FlowView, FlowItem>,
+                     CacheType<FlowView, FlowTransition>,
+                     CacheType<FlowView, FlowView>,
+                     CacheType<FlowView, FlowWildcard>,
+                     CacheType<QML, BoolType>,
+                     CacheType<QML, Component>,
+                     CacheType<QML, DoubleType>,
+                     CacheType<QML, IntType>,
+                     CacheType<QML, QtObject>,
+                     CacheType<QML, date>,
+                     CacheType<QML, string>,
+                     CacheType<QML, url>,
+                     CacheType<QML, var>,
+                     CacheType<QML_cppnative, FloatType>,
+                     CacheType<QtMultimedia, SoundEffect>,
+                     CacheType<QtQml_Models, ListModel>,
+                     CacheType<QtQuick, BorderImage>,
+                     CacheType<QtQuick, Connections>,
+                     CacheType<QtQuick, GridView>,
+                     CacheType<QtQuick, Image>,
+                     CacheType<QtQuick, Item>,
+                     CacheType<QtQuick, ListView>,
+                     CacheType<QtQuick, Loader>,
+                     CacheType<QtQuick, Path>,
+                     CacheType<QtQuick, PathView>,
+                     CacheType<QtQuick, PauseAnimation>,
+                     CacheType<QtQuick, Positioner>,
+                     CacheType<QtQuick, PropertyAnimation>,
+                     CacheType<QtQuick, PropertyChanges>,
+                     CacheType<QtQuick, Rectangle>,
+                     CacheType<QtQuick, Repeater>,
+                     CacheType<QtQuick, State>,
+                     CacheType<QtQuick, StateGroup>,
+                     CacheType<QtQuick, Text>,
+                     CacheType<QtQuick, TextEdit>,
+                     CacheType<QtQuick, Transition>,
+                     CacheType<QtQuick, color>,
+                     CacheType<QtQuick, font>,
+                     CacheType<QtQuick, vector2d>,
+                     CacheType<QtQuick, vector3d>,
+                     CacheType<QtQuick, vector4d>,
+                     CacheType<QtQuick3D, BakedLightmap>,
+                     CacheType<QtQuick3D, Buffer>,
+                     CacheType<QtQuick3D, Camera>,
+                     CacheType<QtQuick3D, Command>,
+                     CacheType<QtQuick3D, CubeMapTexture>,
+                     CacheType<QtQuick3D, DefaultMaterial>,
+                     CacheType<QtQuick3D, Effect>,
+                     CacheType<QtQuick3D, InstanceList>,
+                     CacheType<QtQuick3D, InstanceListEntry>,
+                     CacheType<QtQuick3D, Light>,
+                     CacheType<QtQuick3D, Material>,
+                     CacheType<QtQuick3D, Model>,
+                     CacheType<QtQuick3D, Node>,
+                     CacheType<QtQuick3D, Pass>,
+                     CacheType<QtQuick3D, PrincipledMaterial>,
+                     CacheType<QtQuick3D, SceneEnvironment>,
+                     CacheType<QtQuick3D, SpecularGlossyMaterial>,
+                     CacheType<QtQuick3D, Shader>,
+                     CacheType<QtQuick3D, Texture>,
+                     CacheType<QtQuick3D, TextureInput>,
+                     CacheType<QtQuick3D, View3D>,
+                     CacheType<QtQuick3D_Particles3D, Affector3D>,
+                     CacheType<QtQuick3D_Particles3D, Attractor3D>,
+                     CacheType<QtQuick3D_Particles3D, Model>,
+                     CacheType<QtQuick3D_Particles3D, Particle3D>,
+                     CacheType<QtQuick3D_Particles3D, ParticleEmitter3D>,
+                     CacheType<QtQuick3D_Particles3D, SpriteParticle3D>,
+                     CacheType<QtQuick3D_Particles3D_cppnative, QQuick3DParticleAbstractShape>,
+                     CacheType<QtQuick_Controls, Popup>,
+                     CacheType<QtQuick_Controls, SplitView>,
+                     CacheType<QtQuick_Controls, SwipeView>,
+                     CacheType<QtQuick_Controls, TabBar>,
+                     CacheType<QtQuick_Controls, TextArea>,
+                     CacheType<QtQuick_Dialogs, Dialog>,
+                     CacheType<QtQuick_Extras, Picture>,
+                     CacheType<QtQuick_Layouts, Layout>,
+                     CacheType<QtQuick_Studio_Components, GroupItem>,
+                     CacheType<QtQuick_Timeline, Keyframe>,
+                     CacheType<QtQuick_Timeline, KeyframeGroup>,
+                     CacheType<QtQuick_Timeline, Timeline>,
+                     CacheType<QtQuick_Timeline, TimelineAnimation>,
+                     CacheType<QtQuick_cppnative, QQuickStateOperation>,
+                     CacheType<Qt_SafeRenderer, SafePicture>,
+                     CacheType<Qt_SafeRenderer, SafeRendererPicture>,
+                     CacheType<QtQuick_Window, Window>>;
 
 public:
     CommonTypeCache(const ProjectStorage &projectStorage)

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

@@ -19,10 +19,10 @@ class SourcePathCache;
 template<typename Database>
 class ProjectStorage;
 
-using PathCache = SourcePathCache<ProjectStorage<Sqlite::Database>, NonLockingMutex>;
-
 class FileSystem : public FileSystemInterface
 {
+    using PathCache = SourcePathCache<ProjectStorage<Sqlite::Database>, NonLockingMutex>;
+
 public:
     FileSystem(PathCache &sourcePathCache)
         : m_sourcePathCache(sourcePathCache)

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

@@ -107,6 +107,15 @@ public:
         });
     }
 
+    void synchronizeDocumentImports(Storage::Imports imports, SourceId sourceId) override
+    {
+        Sqlite::withImmediateTransaction(database, [&] {
+            synchronizeDocumentImports(imports,
+                                       {sourceId},
+                                       Storage::Synchronization::ImportKind::Import);
+        });
+    }
+
     ModuleId moduleId(Utils::SmallStringView moduleName) const override
     {
         return moduleCache.id(moduleName);
@@ -139,6 +148,38 @@ public:
             .template valueWithTransaction<TypeId>(moduleId, exportedTypeName);
     }
 
+    TypeId typeId(ImportedTypeNameId typeNameId) const override
+    {
+        return Sqlite::withDeferredTransaction(database, [&] { return fetchTypeId(typeNameId); });
+    }
+
+    ImportId importId(const Storage::Import &import) const override
+    {
+        return Sqlite::withDeferredTransaction(database, [&] {
+            return fetchImportId(import.sourceId, import);
+        });
+    }
+
+    ImportedTypeNameId importedTypeNameId(ImportId importId,
+                                          Utils::SmallStringView typeName) override
+    {
+        return Sqlite::withDeferredTransaction(database, [&] {
+            return fetchImportedTypeNameId(Storage::Synchronization::TypeNameKind::QualifiedExported,
+                                           importId,
+                                           typeName);
+        });
+    }
+
+    ImportedTypeNameId importedTypeNameId(SourceId sourceId,
+                                          Utils::SmallStringView typeName) override
+    {
+        return Sqlite::withDeferredTransaction(database, [&] {
+            return fetchImportedTypeNameId(Storage::Synchronization::TypeNameKind::Exported,
+                                           sourceId,
+                                           typeName);
+        });
+    }
+
     PropertyDeclarationIds propertyDeclarationIds(TypeId typeId) const override
     {
         return selectPropertyDeclarationIdsForTypeStatement
@@ -610,14 +651,14 @@ private:
     template<typename Type>
     struct TypeCompare
     {
-        bool operator()(const Type &type, TypeId typeId) { return type.typeId < typeId; };
+        bool operator()(const Type &type, TypeId typeId) { return type.typeId < typeId; }
 
-        bool operator()(TypeId typeId, const Type &type) { return typeId < type.typeId; };
+        bool operator()(TypeId typeId, const Type &type) { return typeId < type.typeId; }
 
         bool operator()(const Type &first, const Type &second)
         {
             return first.typeId < second.typeId;
-        };
+        }
     };
 
     template<typename Property>
@@ -626,17 +667,17 @@ private:
         bool operator()(const Property &property, PropertyDeclarationId id)
         {
             return property.propertyDeclarationId < id;
-        };
+        }
 
         bool operator()(PropertyDeclarationId id, const Property &property)
         {
             return id < property.propertyDeclarationId;
-        };
+        }
 
         bool operator()(const Property &first, const Property &second)
         {
             return first.propertyDeclarationId < second.propertyDeclarationId;
-        };
+        }
     };
 
     SourceIds filterSourceIdsWithoutType(const SourceIds &updatedSourceIds, SourceIds &sourceIdsOfTypes)
@@ -825,9 +866,9 @@ private:
         Sqlite::insertUpdateDelete(range, fileStatuses, compareKey, insert, update, remove);
     }
 
-    void synchronizeImports(Storage::Synchronization::Imports &imports,
+    void synchronizeImports(Storage::Imports &imports,
                             const SourceIds &updatedSourceIds,
-                            Storage::Synchronization::Imports &moduleDependencies,
+                            Storage::Imports &moduleDependencies,
                             const SourceIds &updatedModuleDependencySourceIds,
                             Storage::Synchronization::ModuleExportedImports &moduleExportedImports,
                             const ModuleIds &updatedModuleIds)
@@ -1484,7 +1525,7 @@ private:
                                 PropertyCompare<AliasPropertyDeclaration>{});
     }
 
-    void insertDocumentImport(const Storage::Synchronization::Import &import,
+    void insertDocumentImport(const Storage::Import &import,
                               Storage::Synchronization::ImportKind importKind,
                               ModuleId sourceModuleId,
                               ModuleExportedImportId moduleExportedImportId)
@@ -1513,7 +1554,7 @@ private:
         }
     }
 
-    void synchronizeDocumentImports(Storage::Synchronization::Imports &imports,
+    void synchronizeDocumentImports(Storage::Imports &imports,
                                     const SourceIds &updatedSourceIds,
                                     Storage::Synchronization::ImportKind importKind)
     {
@@ -1528,7 +1569,7 @@ private:
                                                                                importKind);
 
         auto compareKey = [](const Storage::Synchronization::ImportView &view,
-                             const Storage::Synchronization::Import &import) -> long long {
+                             const Storage::Import &import) -> long long {
             auto sourceIdDifference = view.sourceId - import.sourceId;
             if (sourceIdDifference != 0)
                 return sourceIdDifference;
@@ -1544,16 +1585,15 @@ private:
             return view.version.minor.value - import.version.minor.value;
         };
 
-        auto insert = [&](const Storage::Synchronization::Import &import) {
+        auto insert = [&](const Storage::Import &import) {
             insertDocumentImport(import, importKind, import.moduleId, ModuleExportedImportId{});
             auto callback = [&](ModuleId exportedModuleId,
                                 int majorVersion,
                                 int minorVersion,
                                 ModuleExportedImportId moduleExportedImportId) {
-                Storage::Synchronization::Import additionImport{exportedModuleId,
-                                                                Storage::Version{majorVersion,
-                                                                                 minorVersion},
-                                                                import.sourceId};
+                Storage::Import additionImport{exportedModuleId,
+                                               Storage::Version{majorVersion, minorVersion},
+                                               import.sourceId};
 
                 auto exportedImportKind = importKind == Storage::Synchronization::ImportKind::Import
                                               ? Storage::Synchronization::ImportKind::ModuleExportedImport
@@ -1571,8 +1611,7 @@ private:
                                                                          import.version.minor.value);
         };
 
-        auto update = [](const Storage::Synchronization::ImportView &,
-                         const Storage::Synchronization::Import &) {
+        auto update = [](const Storage::Synchronization::ImportView &, const Storage::Import &) {
             return Sqlite::UpdateChange::No;
         };
 
@@ -2028,7 +2067,7 @@ private:
         removeRelinkableEntries(relinkableExtensions, typeIds, TypeCompare<Prototype>{});
     }
 
-    ImportId fetchImportId(SourceId sourceId, const Storage::Synchronization::Import &import) const
+    ImportId fetchImportId(SourceId sourceId, const Storage::Import &import) const
     {
         if (import.version) {
             return selectImportIdBySourceIdAndModuleIdAndVersionStatement.template value<ImportId>(

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

@@ -9,6 +9,7 @@ class Database;
 
 namespace QmlDesigner {
 class ProjectStorageInterface;
+class SourcePathCacheInterface;
 
 template<typename Database>
 class ProjectStorage;

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

@@ -16,6 +16,7 @@ class ProjectStorageInterface
 {
 public:
     virtual void synchronize(Storage::Synchronization::SynchronizationPackage package) = 0;
+    virtual void synchronizeDocumentImports(const Storage::Imports imports, SourceId sourceId) = 0;
 
     virtual ModuleId moduleId(::Utils::SmallStringView name) const = 0;
     virtual std::optional<Storage::Info::PropertyDeclaration>
@@ -24,6 +25,12 @@ public:
                           ::Utils::SmallStringView exportedTypeName,
                           Storage::Version version) const
         = 0;
+    virtual TypeId typeId(ImportedTypeNameId typeNameId) const = 0;
+    virtual ImportId importId(const Storage::Import &import) const = 0;
+    virtual ImportedTypeNameId importedTypeNameId(ImportId sourceId, Utils::SmallStringView typeName)
+        = 0;
+    virtual ImportedTypeNameId importedTypeNameId(SourceId sourceId, Utils::SmallStringView typeName)
+        = 0;
     virtual PropertyDeclarationIds propertyDeclarationIds(TypeId typeId) const = 0;
     virtual PropertyDeclarationIds localPropertyDeclarationIds(TypeId typeId) const = 0;
     virtual PropertyDeclarationId propertyDeclarationId(TypeId typeId,

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

@@ -79,31 +79,6 @@ public:
     VersionNumber minor;
 };
 
-namespace Synchronization {
-
-enum class TypeNameKind { Exported = 1, QualifiedExported = 2 };
-
-enum class FileType : char { QmlTypes, QmlDocument };
-
-enum class IsQualified : int { No, Yes };
-
-inline int operator-(IsQualified first, IsQualified second)
-{
-    return static_cast<int>(first) - static_cast<int>(second);
-}
-
-inline int operator<(IsQualified first, IsQualified second)
-{
-    return static_cast<int>(first) < static_cast<int>(second);
-}
-
-enum class ImportKind : char {
-    Import,
-    ModuleDependency,
-    ModuleExportedImport,
-    ModuleExportedModuleDependency
-};
-
 class Import
 {
 public:
@@ -141,6 +116,31 @@ public:
 
 using Imports = std::vector<Import>;
 
+namespace Synchronization {
+
+enum class TypeNameKind { Exported = 1, QualifiedExported = 2 };
+
+enum class FileType : char { QmlTypes, QmlDocument };
+
+enum class IsQualified : int { No, Yes };
+
+inline int operator-(IsQualified first, IsQualified second)
+{
+    return static_cast<int>(first) - static_cast<int>(second);
+}
+
+inline int operator<(IsQualified first, IsQualified second)
+{
+    return static_cast<int>(first) < static_cast<int>(second);
+}
+
+enum class ImportKind : char {
+    Import,
+    ModuleDependency,
+    ModuleExportedImport,
+    ModuleExportedModuleDependency
+};
+
 class ImportView
 {
 public:

src/plugins/qmldesigner/designercore/projectstorage/projectstorageupdater.cpp

@@ -125,7 +125,7 @@ Storage::Synchronization::IsAutoVersion convertToIsAutoVersion(QmlDirParser::Imp
     return Storage::Synchronization::IsAutoVersion::No;
 }
 
-void addDependencies(Storage::Synchronization::Imports &dependencies,
+void addDependencies(Storage::Imports &dependencies,
                      SourceId sourceId,
                      const QList<QmlDirParser::Import> &qmldirDependencies,
                      ProjectStorageInterface &projectStorage)

src/plugins/qmldesigner/designercore/projectstorage/qmldocumentparser.cpp

@@ -22,10 +22,11 @@ namespace QmlDesigner {
 #ifdef QDS_BUILD_QMLPARSER
 
 namespace QmlDom = QQmlJS::Dom;
+namespace Synchronization = Storage::Synchronization;
 
 namespace {
 
-using QualifiedImports = std::map<QString, Storage::Synchronization::Import>;
+using QualifiedImports = std::map<QString, Storage::Import>;
 
 int convertVersionNumber(qint32 versionNumber)
 {
@@ -54,10 +55,10 @@ Utils::PathString createNormalizedPath(Utils::SmallStringView directoryPath,
     return normalizedPath;
 }
 
-Storage::Synchronization::Import createImport(const QmlDom::Import &qmlImport,
-                                              SourceId sourceId,
-                                              Utils::SmallStringView directoryPath,
-                                              QmlDocumentParser::ProjectStorage &storage)
+Storage::Import createImport(const QmlDom::Import &qmlImport,
+                             SourceId sourceId,
+                             Utils::SmallStringView directoryPath,
+                             QmlDocumentParser::ProjectStorage &storage)
 {
     using QmlUriKind = QQmlJS::Dom::QmlUri::Kind;
 
@@ -66,16 +67,16 @@ Storage::Synchronization::Import createImport(const QmlDom::Import &qmlImport,
     if (uri.kind() == QmlUriKind::RelativePath) {
         auto path = createNormalizedPath(directoryPath, uri.localPath());
         auto moduleId = storage.moduleId(createNormalizedPath(directoryPath, uri.localPath()));
-        return Storage::Synchronization::Import(moduleId, Storage::Version{}, sourceId);
+        return Storage::Import(moduleId, Storage::Version{}, sourceId);
     }
 
     if (uri.kind() == QmlUriKind::ModuleUri) {
         auto moduleId = storage.moduleId(Utils::PathString{uri.moduleUri()});
-        return Storage::Synchronization::Import(moduleId, convertVersion(qmlImport.version), sourceId);
+        return Storage::Import(moduleId, convertVersion(qmlImport.version), sourceId);
     }
 
     auto moduleId = storage.moduleId(Utils::PathString{uri.toString()});
-    return Storage::Synchronization::Import(moduleId, convertVersion(qmlImport.version), sourceId);
+    return Storage::Import(moduleId, convertVersion(qmlImport.version), sourceId);
 }
 
 QualifiedImports createQualifiedImports(const QList<QmlDom::Import> &qmlImports,
@@ -94,7 +95,7 @@ QualifiedImports createQualifiedImports(const QList<QmlDom::Import> &qmlImports,
     return qualifiedImports;
 }
 
-void addImports(Storage::Synchronization::Imports &imports,
+void addImports(Storage::Imports &imports,
                 const QList<QmlDom::Import> &qmlImports,
                 SourceId sourceId,
                 Utils::SmallStringView directoryPath,
@@ -123,8 +124,8 @@ void addImports(Storage::Synchronization::Imports &imports,
     imports.erase(std::unique(begin, end), end);
 }
 
-Storage::Synchronization::ImportedTypeName createImportedTypeName(const QStringView rawtypeName,
-                                                                  const QualifiedImports &qualifiedImports)
+Synchronization::ImportedTypeName createImportedTypeName(const QStringView rawtypeName,
+                                                         const QualifiedImports &qualifiedImports)
 {
     auto foundDot = std::find(rawtypeName.begin(), rawtypeName.end(), '.');
 
@@ -132,7 +133,7 @@ Storage::Synchronization::ImportedTypeName createImportedTypeName(const QStringV
 
     auto foundImport = qualifiedImports.find(alias.toString());
     if (foundImport == qualifiedImports.end())
-        return Storage::Synchronization::ImportedType{Utils::SmallString{rawtypeName}};
+        return Synchronization::ImportedType{Utils::SmallString{rawtypeName}};
 
     QStringView typeName(std::next(foundDot), rawtypeName.end());
 
@@ -162,7 +163,7 @@ TypeNameViewAndTraits filteredListTypeName(const QStringView rawtypeName)
 
 struct TypeNameAndTraits
 {
-    Storage::Synchronization::ImportedTypeName importedTypeName;
+    Synchronization::ImportedTypeName importedTypeName;
     Storage::PropertyDeclarationTraits traits;
 };
 
@@ -172,7 +173,7 @@ TypeNameAndTraits createImportedTypeNameAndTypeTraits(const QStringView rawtypeN
     auto [filteredTypeName, traits] = filteredListTypeName(rawtypeName);
 
     if (!filteredTypeName.contains('.'))
-        return {Storage::Synchronization::ImportedType{Utils::SmallString{filteredTypeName}}, traits};
+        return {Synchronization::ImportedType{Utils::SmallString{filteredTypeName}}, traits};
 
     return {createImportedTypeName(filteredTypeName, qualifiedImports), traits};
 }
@@ -275,7 +276,7 @@ void addEnumeraton(Storage::Synchronization::Type &type, const QmlDom::Component
 } // namespace
 
 Storage::Synchronization::Type QmlDocumentParser::parse(const QString &sourceContent,
-                                                        Storage::Synchronization::Imports &imports,
+                                                        Storage::Imports &imports,
                                                         SourceId sourceId,
                                                         Utils::SmallStringView directoryPath)
 {
@@ -342,7 +343,7 @@ Storage::Synchronization::Type QmlDocumentParser::parse(const QString &sourceCon
 
 Storage::Synchronization::Type QmlDocumentParser::parse(
     [[maybe_unused]] const QString &sourceContent,
-    [[maybe_unused]] Storage::Synchronization::Imports &imports,
+    [[maybe_unused]] Storage::Imports &imports,
     [[maybe_unused]] SourceId sourceId,
     [[maybe_unused]] Utils::SmallStringView directoryPath)
 {

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

@@ -29,7 +29,7 @@ public:
 #endif
 
     Storage::Synchronization::Type parse(const QString &sourceContent,
-                                         Storage::Synchronization::Imports &imports,
+                                         Storage::Imports &imports,
                                          SourceId sourceId,
                                          Utils::SmallStringView directoryPath) override;
 

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

@@ -13,7 +13,7 @@ class QmlDocumentParserInterface
 {
 public:
     virtual Storage::Synchronization::Type parse(const QString &sourceContent,
-                                                 Storage::Synchronization::Imports &imports,
+                                                 Storage::Imports &imports,
                                                  SourceId sourceId,
                                                  Utils::SmallStringView directoryPath)
         = 0;

src/plugins/qmldesigner/designercore/projectstorage/qmltypesparser.cpp

@@ -49,7 +49,7 @@ ComponentWithoutNamespaces createComponentNameWithoutNamespaces(const QList<QQml
     return componentWithoutNamespaces;
 }
 
-void appendImports(Storage::Synchronization::Imports &imports,
+void appendImports(Storage::Imports &imports,
                    const QString &dependency,
                    SourceId sourceId,
                    QmlTypesParser::ProjectStorage &storage)
@@ -65,7 +65,7 @@ void appendImports(Storage::Synchronization::Imports &imports,
     imports.emplace_back(cppModuleId, Storage::Version{}, sourceId);
 }
 
-void addImports(Storage::Synchronization::Imports &imports,
+void addImports(Storage::Imports &imports,
                 SourceId sourceId,
                 const QStringList &dependencies,
                 QmlTypesParser::ProjectStorage &storage,
@@ -442,7 +442,7 @@ void addTypes(Storage::Synchronization::Types &types,
 } // namespace
 
 void QmlTypesParser::parse(const QString &sourceContent,
-                           Storage::Synchronization::Imports &imports,
+                           Storage::Imports &imports,
                            Storage::Synchronization::Types &types,
                            const Storage::Synchronization::ProjectData &projectData)
 {
@@ -462,7 +462,7 @@ void QmlTypesParser::parse(const QString &sourceContent,
 #else
 
 void QmlTypesParser::parse([[maybe_unused]] const QString &sourceContent,
-                           [[maybe_unused]] Storage::Synchronization::Imports &imports,
+                           [[maybe_unused]] Storage::Imports &imports,
                            [[maybe_unused]] Storage::Synchronization::Types &types,
                            [[maybe_unused]] const Storage::Synchronization::ProjectData &projectData)
 {}

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

@@ -32,7 +32,7 @@ public:
 #endif
 
     void parse(const QString &sourceContent,
-               Storage::Synchronization::Imports &imports,
+               Storage::Imports &imports,
                Storage::Synchronization::Types &types,
                const Storage::Synchronization::ProjectData &projectData) override;
 

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

@@ -13,7 +13,7 @@ class QmlTypesParserInterface
 {
 public:
     virtual void parse(const QString &sourceContent,
-                       Storage::Synchronization::Imports &imports,
+                       Storage::Imports &imports,
                        Storage::Synchronization::Types &types,
                        const Storage::Synchronization::ProjectData &projectData)
         = 0;

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

@@ -6,18 +6,20 @@
 #include "projectstorageexceptions.h"
 #include "projectstorageids.h"
 #include "sourcepath.h"
+#include "sourcepathcacheinterface.h"
 #include "sourcepathcachetypes.h"
 #include "sourcepathview.h"
 #include "storagecache.h"
 
+#include <modelfwd.h>
 #include <sqlitetransaction.h>
 
 #include <algorithm>
 
 namespace QmlDesigner {
 
-template<typename ProjectStorage, typename Mutex = NonLockingMutex>
-class SourcePathCache
+template<typename ProjectStorage, typename Mutex>
+class SourcePathCache final : public SourcePathCacheInterface
 {
     SourcePathCache(const SourcePathCache &) = default;
     SourcePathCache &operator=(const SourcePathCache &) = default;
@@ -37,7 +39,7 @@ public:
     SourcePathCache(SourcePathCache &&) = default;
     SourcePathCache &operator=(SourcePathCache &&) = default;
 
-    void populateIfEmpty()
+    void populateIfEmpty() override
     {
         if (m_sourcePathCache.isEmpty()) {
             m_sourceContextPathCache.populate();
@@ -45,7 +47,8 @@ public:
         }
     }
 
-    std::pair<SourceContextId, SourceId> sourceContextAndSourceId(SourcePathView sourcePath) const
+    std::pair<SourceContextId, SourceId> sourceContextAndSourceId(
+        SourcePathView sourcePath) const override
     {
         Utils::SmallStringView sourceContextPath = sourcePath.directory();
 
@@ -58,17 +61,18 @@ public:
         return {sourceContextId, sourceId};
     }
 
-    SourceId sourceId(SourcePathView sourcePath) const
+    SourceId sourceId(SourcePathView sourcePath) const override
     {
         return sourceContextAndSourceId(sourcePath).second;
     }
 
-    SourceId sourceId(SourceContextId sourceContextId, Utils::SmallStringView sourceName) const
+    SourceId sourceId(SourceContextId sourceContextId,
+                      Utils::SmallStringView sourceName) const override
     {
         return m_sourcePathCache.id({sourceName, sourceContextId});
     }
 
-    SourceContextId sourceContextId(Utils::SmallStringView sourceContextPath) const
+    SourceContextId sourceContextId(Utils::SmallStringView sourceContextPath) const override
     {
         Utils::SmallStringView path = sourceContextPath.back() == '/'
                                           ? sourceContextPath.mid(0, sourceContextPath.size() - 1)
@@ -77,7 +81,7 @@ public:
         return m_sourceContextPathCache.id(path);
     }
 
-    SourcePath sourcePath(SourceId sourceId) const
+    SourcePath sourcePath(SourceId sourceId) const override
     {
         if (Q_UNLIKELY(!sourceId.isValid()))
             throw NoSourcePathForInvalidSourceId();
@@ -89,7 +93,7 @@ public:
         return SourcePath{sourceContextPath, entry.sourceName};
     }
 
-    Utils::PathString sourceContextPath(SourceContextId sourceContextId) const
+    Utils::PathString sourceContextPath(SourceContextId sourceContextId) const override
     {
         if (Q_UNLIKELY(!sourceContextId.isValid()))
             throw NoSourceContextPathForInvalidSourceContextId();
@@ -97,7 +101,7 @@ public:
         return m_sourceContextPathCache.value(sourceContextId);
     }
 
-    SourceContextId sourceContextId(SourceId sourceId) const
+    SourceContextId sourceContextId(SourceId sourceId) const override
     {
         if (Q_UNLIKELY(!sourceId.isValid()))
             throw NoSourcePathForInvalidSourceId();

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

@@ -0,0 +1,44 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include "sourcepath.h"
+#include "sourcepathcachetypes.h"
+#include "sourcepathview.h"
+
+namespace QmlDesigner {
+
+class SourcePathCacheInterface
+{
+    SourcePathCacheInterface(const SourcePathCacheInterface &) = default;
+    SourcePathCacheInterface &operator=(const SourcePathCacheInterface &) = default;
+
+public:
+    SourcePathCacheInterface() = default;
+
+    SourcePathCacheInterface(SourcePathCacheInterface &&) = default;
+    SourcePathCacheInterface &operator=(SourcePathCacheInterface &&) = default;
+
+    virtual void populateIfEmpty() = 0;
+
+    virtual std::pair<SourceContextId, SourceId>
+    sourceContextAndSourceId(SourcePathView sourcePath) const = 0;
+
+    virtual SourceId sourceId(SourcePathView sourcePath) const = 0;
+
+    virtual SourceId sourceId(SourceContextId sourceContextId,
+                              Utils::SmallStringView sourceName) const
+        = 0;
+
+    virtual SourceContextId sourceContextId(Utils::SmallStringView sourceContextPath) const = 0;
+
+    virtual SourcePath sourcePath(SourceId sourceId) const = 0;
+
+    virtual Utils::PathString sourceContextPath(SourceContextId sourceContextId) const = 0;
+    virtual SourceContextId sourceContextId(SourceId sourceId) const = 0;
+
+protected:
+    ~SourcePathCacheInterface() = default;
+};
+} // namespace QmlDesigner

src/plugins/qmldesigner/documentmanager.cpp

@@ -39,12 +39,12 @@ namespace QmlDesigner {
 
 Q_LOGGING_CATEGORY(documentManagerLog, "qtc.qtquickdesigner.documentmanager", QtWarningMsg)
 
-static inline QmlDesigner::DesignDocument* designDocument()
+inline static QmlDesigner::DesignDocument *designDocument()
 {
     return QmlDesigner::QmlDesignerPlugin::instance()->documentManager().currentDesignDocument();
 }
 
-static inline QHash<PropertyName, QVariant> getProperties(const ModelNode &node)
+inline static QHash<PropertyName, QVariant> getProperties(const ModelNode &node)
 {
     QHash<PropertyName, QVariant> propertyHash;
     if (QmlObjectNode::isValidQmlObjectNode(node)) {
@@ -71,7 +71,7 @@ static inline QHash<PropertyName, QVariant> getProperties(const ModelNode &node)
     return propertyHash;
 }
 
-static inline void applyProperties(ModelNode &node, const QHash<PropertyName, QVariant> &propertyHash)
+inline static void applyProperties(ModelNode &node, const QHash<PropertyName, QVariant> &propertyHash)
 {
     const auto auxiliaryData = node.auxiliaryData(AuxiliaryDataType::NodeInstancePropertyOverwrite);
 
@@ -168,7 +168,7 @@ static void handleTabComponent(const ModelNode &modelNode)
     }
 }
 
-static inline void openInlineComponent(const ModelNode &modelNode)
+inline static void openInlineComponent(const ModelNode &modelNode)
 {
     if (!modelNode.metaInfo().isValid())
         return;
@@ -227,7 +227,7 @@ void DocumentManager::setCurrentDesignDocument(Core::IEditor *editor)
         auto found = m_designDocuments.find(editor);
         if (found == m_designDocuments.end()) {
             auto &inserted = m_designDocuments[editor] = std::make_unique<DesignDocument>(
-                m_projectManager.projectStorage(), m_externalDependencies);
+                m_projectManager.projectStorageDependencies(), m_externalDependencies);
             m_currentDesignDocument = inserted.get();
             m_currentDesignDocument->setEditor(editor);
         } else {

src/plugins/qmldesigner/qmldesignerprojectmanager.cpp

@@ -181,7 +181,7 @@ public:
     {}
     Sqlite::Database database;
     ProjectStorage<Sqlite::Database> storage{database, database.isInitialized()};
-    ProjectStorageUpdater::PathCache pathCache{storage};
+    PathCacheType pathCache{storage};
     FileSystem fileSystem{pathCache};
     FileStatusCache fileStatusCache{fileSystem};
     QmlDocumentParser qmlDocumentParser{storage, pathCache};
@@ -286,14 +286,20 @@ ProjectStorage<Sqlite::Database> *dummyProjectStorage()
     return nullptr;
 }
 
+ProjectStorageUpdater::PathCache *dummyPathCache()
+{
+    return nullptr;
+}
+
 } // namespace
 
-ProjectStorage<Sqlite::Database> &QmlDesignerProjectManager::projectStorage()
+ProjectStorageDependencies QmlDesignerProjectManager::projectStorageDependencies()
 {
     if constexpr (useProjectStorage()) {
-        return m_projectData->projectStorageData->storage;
+        return {m_projectData->projectStorageData->storage,
+                m_projectData->projectStorageData->pathCache};
     } else {
-        return *dummyProjectStorage();
+        return {*dummyProjectStorage(), *dummyPathCache()};
     }
 }
 

src/plugins/qmldesigner/qmldesignerprojectmanager.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "modelfwd.h"
 #include <projectstoragefwd.h>
 
 #include <QList>
@@ -42,7 +43,7 @@ public:
     void registerPreviewImageProvider(QQmlEngine *engine) const;
 
     class AsynchronousImageCache &asynchronousImageCache();
-    ProjectStorage<Sqlite::Database> &projectStorage();
+    ProjectStorageDependencies projectStorageDependencies();
 
 private:
     void editorOpened(::Core::IEditor *editor);

tests/unit/tests/matchers/CMakeLists.txt

@@ -3,7 +3,8 @@ add_qtc_library(TestMatchers OBJECT
   SKIP_AUTOMOC ON
   PUBLIC_INCLUDES ${CMAKE_CURRENT_LIST_DIR}
   DEPENDS
-    Googletest Utils
+    Googletest Utils QmlDesigner
   SOURCES
+    import-matcher.h
     unittest-matchers.h
 )

tests/unit/tests/matchers/import-matcher.h

@@ -0,0 +1,59 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include <projectstorage/projectstoragetypes.h>
+
+#include <gmock/gmock-matchers.h>
+#include <gmock/gmock-more-matchers.h>
+
+template<typename Matcher>
+auto IsVersionNumber(const Matcher &matcher)
+{
+    return Field(&QmlDesigner::Storage::VersionNumber::value, matcher);
+}
+
+template<typename Matcher>
+auto IsMinorVersion(const Matcher &matcher)
+{
+    return Field(&QmlDesigner::Storage::Version::minor, matcher);
+}
+
+template<typename Matcher>
+auto IsMajorVersion(const Matcher &matcher)
+{
+    return Field(&QmlDesigner::Storage::Version::major, matcher);
+}
+
+template<typename MajorMatcher, typename MinorMatcher>
+auto IsVersion(const MajorMatcher &majorMatcher, const MinorMatcher &minorMatcher)
+{
+    return AllOf(IsMajorVersion(IsVersionNumber(majorMatcher)),
+                 IsMinorVersion(IsVersionNumber(minorMatcher)));
+}
+
+template<typename ModuleIdMatcher,
+         typename SourceIdMatcher,
+         typename MajorVersionMatcher,
+         typename MinorVersionMatcher>
+auto IsImport(const ModuleIdMatcher &moduleIdMatcher,
+              const SourceIdMatcher &sourceIdMatcher,
+              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,
+                       IsVersion(majorVersionMatcher, minorVersionMatcher)));
+}
+
+template<typename ModuleIdMatcher, typename SourceIdMatcher, typename VersionMatcher>
+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));
+}

tests/unit/tests/mocks/CMakeLists.txt

@@ -27,7 +27,7 @@ add_qtc_library(TestMocks OBJECT
     projectstoragepathwatchernotifiermock.h
     qmldocumentparsermock.h
     qmltypesparsermock.h
-    sourcepathcachemock.h
+    sourcepathcachemock.h sourcepathcachemock.cpp
     sqlitedatabasemock.h
     sqlitereadstatementmock.cpp
     sqlitereadstatementmock.h

tests/unit/tests/mocks/projectstoragemock.cpp

@@ -3,10 +3,15 @@
 
 #include "projectstoragemock.h"
 
+#include <matchers/import-matcher.h>
+
 #include <projectstorage/projectstorageinfotypes.h>
 
+using QmlDesigner::ImportedTypeNameId;
+using QmlDesigner::ImportId;
 using QmlDesigner::ModuleId;
 using QmlDesigner::PropertyDeclarationId;
+using QmlDesigner::SourceId;
 using QmlDesigner::TypeId;
 using QmlDesigner::TypeIds;
 using QmlDesigner::Storage::PropertyDeclarationTraits;
@@ -46,6 +51,54 @@ ModuleId ProjectStorageMock::createModule(Utils::SmallStringView moduleName)
     return moduleId;
 }
 
+QmlDesigner::ImportedTypeNameId ProjectStorageMock::createImportedTypeNameId(
+    SourceId sourceId, Utils::SmallStringView typeName, TypeId typeId)
+{
+    static ImportedTypeNameId importedTypeNameId;
+    incrementBasicId(importedTypeNameId);
+
+    ON_CALL(*this, importedTypeNameId(sourceId, Eq(typeName)))
+        .WillByDefault(Return(importedTypeNameId));
+
+    ON_CALL(*this, typeId(importedTypeNameId)).WillByDefault(Return(typeId));
+
+    return importedTypeNameId;
+}
+
+QmlDesigner::ImportedTypeNameId ProjectStorageMock::createImportedTypeNameId(
+    QmlDesigner::SourceId sourceId, Utils::SmallStringView typeName, QmlDesigner::ModuleId moduleId)
+{
+    return createImportedTypeNameId(sourceId,
+                                    typeName,
+                                    typeId(moduleId, typeName, QmlDesigner::Storage::Version{}));
+}
+
+QmlDesigner::ImportedTypeNameId ProjectStorageMock::createImportedTypeNameId(
+    QmlDesigner::ImportId importId, Utils::SmallStringView typeName, QmlDesigner::TypeId typeId)
+{
+    static ImportedTypeNameId importedTypeNameId;
+    incrementBasicId(importedTypeNameId);
+
+    ON_CALL(*this, importedTypeNameId(importId, Eq(typeName)))
+        .WillByDefault(Return(importedTypeNameId));
+
+    ON_CALL(*this, typeId(importedTypeNameId)).WillByDefault(Return(typeId));
+
+    return importedTypeNameId;
+}
+
+QmlDesigner::ImportId ProjectStorageMock::createImportId(QmlDesigner::ModuleId moduleId,
+                                                         QmlDesigner::SourceId sourceId,
+                                                         QmlDesigner::Storage::Version version)
+{
+    static ImportId importId;
+    incrementBasicId(importId);
+
+    ON_CALL(*this, importId(IsImport(moduleId, sourceId, version))).WillByDefault(Return(importId));
+
+    return importId;
+}
+
 PropertyDeclarationId ProjectStorageMock::createProperty(TypeId typeId,
                                                          Utils::SmallString name,
                                                          PropertyDeclarationTraits traits,
@@ -155,7 +208,7 @@ TypeId ProjectStorageMock::createObject(ModuleId moduleId,
     return createType(moduleId, typeName, Storage::TypeTraits::Reference, baseTypeIds);
 }
 
-void ProjectStorageMock::setupQtQtuick()
+void ProjectStorageMock::setupQtQuick()
 {
     setupIsBasedOn(*this);
 
@@ -239,6 +292,37 @@ void ProjectStorageMock::setupQtQtuick()
                  {qtObjectId, itemId});
 }
 
+void ProjectStorageMock::setupQtQuickImportedTypeNameIds(QmlDesigner::SourceId sourceId)
+{
+    auto qmlModuleId = moduleId("QML");
+    auto qtQmlModelsModuleId = moduleId("QtQml.Models");
+    auto qtQuickModuleId = moduleId("QtQuick");
+    auto qtQuickNativeModuleId = moduleId("QtQuick-cppnative");
+    auto qtQuickTimelineModuleId = moduleId("QtQuick.Timeline");
+    auto flowViewModuleId = moduleId("FlowView");
+
+    createImportedTypeNameId(sourceId, "int", qmlModuleId);
+    createImportedTypeNameId(sourceId, "QtObject", qmlModuleId);
+    createImportedTypeNameId(sourceId, "ListElement", qtQmlModelsModuleId);
+    createImportedTypeNameId(sourceId, "ListModel", qtQmlModelsModuleId);
+    createImportedTypeNameId(sourceId, "Item", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "ListView", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "StateGroup", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "State", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "Animation", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "Transition", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "PropertyAnimation", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "QQuickStateOperation", qtQuickNativeModuleId);
+    createImportedTypeNameId(sourceId, "PropertyChanges", qtQuickModuleId);
+    createImportedTypeNameId(sourceId, "KeyframeGroup", qtQuickTimelineModuleId);
+    createImportedTypeNameId(sourceId, "Keyframe", qtQuickTimelineModuleId);
+    createImportedTypeNameId(sourceId, "FlowActionArea", flowViewModuleId);
+    createImportedTypeNameId(sourceId, "FlowWildcard", flowViewModuleId);
+    createImportedTypeNameId(sourceId, "FlowDecision", flowViewModuleId);
+    createImportedTypeNameId(sourceId, "FlowTransition", flowViewModuleId);
+    createImportedTypeNameId(sourceId, "FlowItem", flowViewModuleId);
+}
+
 void ProjectStorageMock::setupCommonTypeCache()
 {
     ON_CALL(*this, commonTypeCache()).WillByDefault(ReturnRef(typeCache));

tests/unit/tests/mocks/projectstoragemock.h

@@ -15,11 +15,31 @@
 class ProjectStorageMock : public QmlDesigner::ProjectStorageInterface
 {
 public:
-    void setupQtQtuick();
+    virtual ~ProjectStorageMock() = default;
+
+    void setupQtQuick();
+    void setupQtQuickImportedTypeNameIds(QmlDesigner::SourceId sourceId);
     void setupCommonTypeCache();
 
     QmlDesigner::ModuleId createModule(Utils::SmallStringView moduleName);
 
+    QmlDesigner::ImportedTypeNameId createImportedTypeNameId(QmlDesigner::SourceId sourceId,
+                                                             Utils::SmallStringView typeName,
+                                                             QmlDesigner::TypeId typeId);
+
+    QmlDesigner::ImportedTypeNameId createImportedTypeNameId(QmlDesigner::SourceId sourceId,
+                                                             Utils::SmallStringView typeName,
+                                                             QmlDesigner::ModuleId moduleId);
+
+    QmlDesigner::ImportedTypeNameId createImportedTypeNameId(QmlDesigner::ImportId importId,
+                                                             Utils::SmallStringView typeName,
+                                                             QmlDesigner::TypeId typeId);
+
+    QmlDesigner::ImportId createImportId(
+        QmlDesigner::ModuleId moduleId,
+        QmlDesigner::SourceId sourceId,
+        QmlDesigner::Storage::Version version = QmlDesigner::Storage::Version{});
+
     QmlDesigner::TypeId createType(
         QmlDesigner::ModuleId moduleId,
         Utils::SmallStringView typeName,
@@ -63,6 +83,10 @@ public:
                 synchronize,
                 (QmlDesigner::Storage::Synchronization::SynchronizationPackage package),
                 (override));
+    MOCK_METHOD(void,
+                synchronizeDocumentImports,
+                (const QmlDesigner::Storage::Imports imports, QmlDesigner::SourceId sourceId),
+                (override));
 
     MOCK_METHOD(QmlDesigner::ModuleId, moduleId, (::Utils::SmallStringView), (const, override));
 
@@ -71,6 +95,11 @@ public:
                 (QmlDesigner::PropertyDeclarationId propertyDeclarationId),
                 (const, override));
 
+    MOCK_METHOD(QmlDesigner::TypeId,
+                typeId,
+                (QmlDesigner::ImportedTypeNameId typeNameId),
+                (const, override));
+
     MOCK_METHOD(QmlDesigner::TypeId,
                 typeId,
                 (QmlDesigner::ModuleId moduleId,
@@ -78,6 +107,19 @@ public:
                  QmlDesigner::Storage::Version version),
                 (const, override));
 
+    MOCK_METHOD(QmlDesigner::ImportId,
+                importId,
+                (const QmlDesigner::Storage::Import &import),
+                (const, override));
+    MOCK_METHOD(QmlDesigner::ImportedTypeNameId,
+                importedTypeNameId,
+                (QmlDesigner::ImportId sourceId, ::Utils::SmallStringView typeName),
+                (override));
+    MOCK_METHOD(QmlDesigner::ImportedTypeNameId,
+                importedTypeNameId,
+                (QmlDesigner::SourceId sourceId, ::Utils::SmallStringView typeName),
+                (override));
+
     MOCK_METHOD(QmlDesigner::PropertyDeclarationIds,
                 propertyDeclarationIds,
                 (QmlDesigner::TypeId typeId),
@@ -207,9 +249,10 @@ public:
 class ProjectStorageMockWithQtQtuick : public ProjectStorageMock
 {
 public:
-    ProjectStorageMockWithQtQtuick()
+    ProjectStorageMockWithQtQtuick(QmlDesigner::SourceId sourceId)
     {
-        setupQtQtuick();
+        setupQtQuick();
+        setupQtQuickImportedTypeNameIds(sourceId);
         setupCommonTypeCache();
     }
 };

tests/unit/tests/mocks/qmldocumentparsermock.h

@@ -13,7 +13,7 @@ public:
     MOCK_METHOD(QmlDesigner::Storage::Synchronization::Type,
                 parse,
                 (const QString &sourceContent,
-                 QmlDesigner::Storage::Synchronization::Imports &imports,
+                 QmlDesigner::Storage::Imports &imports,
                  QmlDesigner::SourceId sourceId,
                  Utils::SmallStringView directoryPath),
                 (override));

tests/unit/tests/mocks/qmltypesparsermock.h

@@ -13,7 +13,7 @@ public:
     MOCK_METHOD(void,
                 parse,
                 (const QString &sourceContent,
-                 QmlDesigner::Storage::Synchronization::Imports &imports,
+                 QmlDesigner::Storage::Imports &imports,
                  QmlDesigner::Storage::Synchronization::Types &types,
                  const QmlDesigner::Storage::Synchronization::ProjectData &projectData),
                 (override));

tests/unit/tests/mocks/sourcepathcachemock.cpp

@@ -0,0 +1,31 @@
+// Copyright (C) 2023 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "sourcepathcachemock.h"
+
+namespace {
+
+template<typename BasicId>
+void incrementBasicId(BasicId &id)
+{
+    id = BasicId::create(id.internalId() + 1);
+}
+} // namespace
+
+QmlDesigner::SourceId SourcePathCacheMock::createSourceId(QmlDesigner::SourcePathView path)
+{
+    static QmlDesigner::SourceId id;
+
+    incrementBasicId(id);
+
+    ON_CALL(*this, sourceId(Eq(path))).WillByDefault(Return(id));
+    ON_CALL(*this, sourcePath(Eq(id))).WillByDefault(Return(path));
+
+    return id;
+}
+
+SourcePathCacheMockWithPaths::SourcePathCacheMockWithPaths(QmlDesigner::SourcePathView path)
+    : path{path}
+{
+    sourceId = createSourceId(path);
+}

tests/unit/tests/mocks/sourcepathcachemock.h

@@ -6,21 +6,53 @@
 #include "../utils/googletest.h"
 
 #include <projectstorage/sourcepath.h>
+#include <projectstorage/sourcepathcacheinterface.h>
 #include <projectstorageids.h>
 
-class SourcePathCacheMock
+class SourcePathCacheMock : public QmlDesigner::SourcePathCacheInterface
 {
 public:
-    MOCK_METHOD(QmlDesigner::SourceId, sourceId, (QmlDesigner::SourcePathView sourcePath), (const));
-    MOCK_METHOD(QmlDesigner::SourcePath, sourcePath, (QmlDesigner::SourceId sourceId), (const));
+    virtual ~SourcePathCacheMock() = default;
+
+    QmlDesigner::SourceId createSourceId(QmlDesigner::SourcePathView path);
+
+    MOCK_METHOD(QmlDesigner::SourceId,
+                sourceId,
+                (QmlDesigner::SourcePathView sourcePath),
+                (const, override));
+    MOCK_METHOD(QmlDesigner::SourceId,
+                sourceId,
+                (QmlDesigner::SourceContextId sourceContextId, Utils::SmallStringView sourceName),
+                (const, override));
+    MOCK_METHOD(QmlDesigner::SourcePath,
+                sourcePath,
+                (QmlDesigner::SourceId sourceId),
+                (const, override));
     MOCK_METHOD(QmlDesigner::SourceContextId,
                 sourceContextId,
                 (Utils::SmallStringView directoryPath),
-                (const));
+                (const, override));
+    using SourceContextAndSourceId = std::pair<QmlDesigner::SourceContextId, QmlDesigner::SourceId>;
+    MOCK_METHOD(SourceContextAndSourceId,
+                sourceContextAndSourceId,
+                (QmlDesigner::SourcePathView sourcePath),
+                (const, override));
     MOCK_METHOD(Utils::PathString,
                 sourceContextPath,
                 (QmlDesigner::SourceContextId directoryPathId),
-                (const));
-    MOCK_METHOD(QmlDesigner::SourceContextId, sourceContextId, (QmlDesigner::SourceId sourceId), (const));
-    MOCK_METHOD(void, populateIfEmpty, ());
+                (const, override));
+    MOCK_METHOD(QmlDesigner::SourceContextId,
+                sourceContextId,
+                (QmlDesigner::SourceId sourceId),
+                (const, override));
+    MOCK_METHOD(void, populateIfEmpty, (), (override));
+};
+
+class SourcePathCacheMockWithPaths : public SourcePathCacheMock
+{
+public:
+    SourcePathCacheMockWithPaths(QmlDesigner::SourcePathView path);
+
+    QmlDesigner::SourcePath path;
+    QmlDesigner::SourceId sourceId;
 };

tests/unit/tests/printers/gtest-creator-printing.cpp

@@ -14,6 +14,7 @@
 #include <imagecacheauxiliarydata.h>
 #include <import.h>
 #include <modelnode.h>
+#include <nodemetainfo.h>
 #include <projectstorage/filestatus.h>
 #include <projectstorage/projectstoragepathwatchertypes.h>
 #include <projectstorage/projectstoragetypes.h>
@@ -464,6 +465,12 @@ std::ostream &operator<<(std::ostream &out, const ModelNode &node)
 
     return out << "(" << node.id() << ")";
 }
+
+std::ostream &operator<<(std::ostream &out, const NodeMetaInfo &metaInfo)
+{
+    return out << "(" << metaInfo.id() << ")";
+}
+
 std::ostream &operator<<(std::ostream &out, const VariantProperty &property)
 {
     if (!property.isValid())
@@ -574,6 +581,10 @@ std::ostream &operator<<(std::ostream &out, Version version)
     return out << "(" << version.major << ", " << version.minor << ")";
 }
 
+std::ostream &operator<<(std::ostream &out, const Import &import)
+{
+    return out << "(" << import.moduleId << ", " << import.version << ", " << import.sourceId << ")";
+}
 } // namespace Storage
 
 namespace Storage::Info {
@@ -773,11 +784,6 @@ std::ostream &operator<<(std::ostream &out, const IsAutoVersion &isAutoVersion)
     return out << isAutoVersionToText(isAutoVersion);
 }
 
-std::ostream &operator<<(std::ostream &out, const Import &import)
-{
-    return out << "(" << import.moduleId << ", " << import.version << ", " << import.sourceId << ")";
-}
-
 std::ostream &operator<<(std::ostream &out, const ModuleExportedImport &import)
 {
     return out << "(" << import.moduleId << ", " << import.exportedModuleId << ", "

tests/unit/tests/printers/gtest-creator-printing.h

@@ -13,8 +13,6 @@
 #include <optional>
 #include <variant>
 
-#include <gtest/gtest-printers.h>
-
 namespace Sqlite {
 class Value;
 class ValueView;
@@ -123,6 +121,7 @@ class ProjectChunkId;
 enum class SourceType : int;
 class FileStatus;
 class Import;
+class NodeMetaInfo;
 
 std::ostream &operator<<(std::ostream &out, const ModelNode &node);
 std::ostream &operator<<(std::ostream &out, const VariantProperty &property);
@@ -135,6 +134,7 @@ std::ostream &operator<<(std::ostream &out, const FileStatus &fileStatus);
 std::ostream &operator<<(std::ostream &out, const Import &import);
 std::ostream &operator<<(std::ostream &out, const ModelResourceSet::SetExpression &setExpression);
 std::ostream &operator<<(std::ostream &out, const ModelResourceSet &modelResourceSet);
+std::ostream &operator<<(std::ostream &out, const NodeMetaInfo &metaInfo);
 
 namespace Cache {
 class SourceContext;
@@ -155,22 +155,25 @@ std::ostream &operator<<(std::ostream &out, const FontCollectorSizesAuxiliaryDat
 namespace Storage {
 enum class PropertyDeclarationTraits : int;
 enum class TypeTraits : int;
+class Import;
+class Version;
+class VersionNumber;
 
 std::ostream &operator<<(std::ostream &out, PropertyDeclarationTraits traits);
 std::ostream &operator<<(std::ostream &out, TypeTraits traits);
+std::ostream &operator<<(std::ostream &out, const Import &import);
+std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber);
+std::ostream &operator<<(std::ostream &out, Version version);
 
 } // namespace Storage
 
 namespace Storage::Info {
 class ProjectDeclaration;
 class Type;
-class Version;
-class VersionNumber;
 
 std::ostream &operator<<(std::ostream &out, const ProjectDeclaration &declaration);
 std::ostream &operator<<(std::ostream &out, const Type &type);
-std::ostream &operator<<(std::ostream &out, VersionNumber versionNumber);
-std::ostream &operator<<(std::ostream &out, Version version);
+
 } // namespace Storage::Info
 
 namespace Storage::Synchronization {
@@ -186,7 +189,6 @@ class EnumerationDeclaration;
 class EnumeratorDeclaration;
 enum class ImportKind : char;
 enum class IsAutoVersion : char;
-class Import;
 enum class IsQualified : int;
 class ProjectData;
 class SynchronizationPackage;
@@ -205,7 +207,6 @@ std::ostream &operator<<(std::ostream &out, const SignalDeclaration &signalDecla
 std::ostream &operator<<(std::ostream &out, const EnumerationDeclaration &enumerationDeclaration);
 std::ostream &operator<<(std::ostream &out, const EnumeratorDeclaration &enumeratorDeclaration);
 std::ostream &operator<<(std::ostream &out, const ImportKind &importKind);
-std::ostream &operator<<(std::ostream &out, const Import &import);
 std::ostream &operator<<(std::ostream &out, IsQualified isQualified);
 std::ostream &operator<<(std::ostream &out, const ProjectData &data);
 std::ostream &operator<<(std::ostream &out, const SynchronizationPackage &package);

tests/unit/tests/unittests/listmodeleditor/listmodeleditor-test.cpp

@@ -3,8 +3,9 @@
 
 #include "../utils/googletest.h"
 
-#include "../mocks/mocklistmodeleditorview.h"
-#include "../mocks/projectstoragemock.h"
+#include <mocks/mocklistmodeleditorview.h>
+#include <mocks/projectstoragemock.h>
+#include <mocks/sourcepathcachemock.h>
 
 #include <qmldesigner/components/listmodeleditor/listmodeleditormodel.h>
 #include <qmldesigner/designercore/include/abstractview.h>
@@ -70,15 +71,18 @@ MATCHER_P2(IsAbstractProperty, node, name, std::string(negation ? "isn't " : "is
 
 class ListModelEditor : public testing::Test
 {
+    using SourcePathCache = QmlDesigner::SourcePathCache<NiceMock<ProjectStorageMockWithQtQtuick>,
+                                                         QmlDesigner::NonLockingMutex>;
+
 public:
     ListModelEditor()
     {
         designerModel->attachView(&mockView);
 
-        emptyListModelNode = mockView.createModelNode("QtQml.Models.ListModel", 2, 15);
+        emptyListModelNode = mockView.createModelNode("ListModel");
 
-        listViewNode = mockView.createModelNode("QtQuick.ListView", 2, 15);
-        listModelNode = mockView.createModelNode("QtQml.Models.ListModel", 2, 15);
+        listViewNode = mockView.createModelNode("ListView");
+        listModelNode = mockView.createModelNode("ListModel");
         mockView.rootModelNode().defaultNodeListProperty().reparentHere(listModelNode);
         element1 = createElement({{"name", "foo"}, {"value", 1}, {"value2", 42}},
                                  mockView,
@@ -91,6 +95,7 @@ public:
                                  listModelNode);
 
         componentModel->attachView(&mockComponentView);
+        mockComponentView.changeRootNodeType("ListModel", -1, -1);
 
         componentElement = createElement({{"name", "com"}, {"value", 11}, {"value2", 55}},
                                          mockComponentView,
@@ -178,15 +183,20 @@ public:
     }
 
 protected:
-    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock;
+    NiceMock<SourcePathCacheMockWithPaths> pathCacheMock{"/path/foo.qml"};
+    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock{pathCacheMock.sourceId};
     NiceMock<MockFunction<ModelNode(const ModelNode &)>> goIntoComponentMock;
     QmlDesigner::ModelPointer designerModel{
-        QmlDesigner::Model::create(projectStorageMock, "QtQuick.Item", 1, 1)};
+        QmlDesigner::Model::create(QmlDesigner::ProjectStorageDependencies{projectStorageMock,
+                                                                           pathCacheMock},
+                                   "Item",
+                                   {QmlDesigner::Import::createLibraryImport("QtQml.Models"),
+                                    QmlDesigner::Import::createLibraryImport("QtQuick")},
+                                   pathCacheMock.path.toQString())};
     NiceMock<MockListModelEditorView> mockView;
-    QmlDesigner::ListModelEditorModel model{
-        [&] { return mockView.createModelNode("QtQml.Models.ListModel", 2, 15); },
-        [&] { return mockView.createModelNode("QtQml.Models.ListElement", 2, 15); },
-        goIntoComponentMock.AsStdFunction()};
+    QmlDesigner::ListModelEditorModel model{[&] { return mockView.createModelNode("ListModel"); },
+                                            [&] { return mockView.createModelNode("ListElement"); },
+                                            goIntoComponentMock.AsStdFunction()};
     ModelNode listViewNode;
     ModelNode listModelNode;
     ModelNode emptyListModelNode;
@@ -194,7 +204,11 @@ protected:
     ModelNode element2;
     ModelNode element3;
     QmlDesigner::ModelPointer componentModel{
-        QmlDesigner::Model::create(projectStorageMock, "QtQml.Models.ListModel", 1, 1)};
+        QmlDesigner::Model::create({projectStorageMock, pathCacheMock},
+                                   "ListModel",
+                                   {QmlDesigner::Import::createLibraryImport("QtQml.Models"),
+                                    QmlDesigner::Import::createLibraryImport("QtQuick")},
+                                   pathCacheMock.path.toQString())};
     NiceMock<MockListModelEditorView> mockComponentView;
     ModelNode componentElement;
 };
@@ -289,9 +303,9 @@ TEST_F(ListModelEditor, add_row_creates_new_model_node_and_reparents)
 {
     model.setListModel(listModelNode);
 
-    EXPECT_CALL(mockView, nodeCreated(Property(&ModelNode::type, Eq("QtQml.Models.ListElement"))));
+    EXPECT_CALL(mockView, nodeCreated(Property(&ModelNode::type, Eq("ListElement"))));
     EXPECT_CALL(mockView,
-                nodeReparented(Property(&ModelNode::type, Eq("QtQml.Models.ListElement")),
+                nodeReparented(Property(&ModelNode::type, Eq("ListElement")),
                                Property(&AbstractProperty::parentModelNode, Eq(listModelNode)),
                                _,
                                _));
@@ -1284,7 +1298,7 @@ TEST_F(ListModelEditor, list_view_has_no_model)
 {
     model.setListView(listViewNode);
 
-    ASSERT_THAT(listViewNode.nodeProperty("model").modelNode().type(), Eq("QtQml.Models.ListModel"));
+    ASSERT_THAT(listViewNode.nodeProperty("model").modelNode().type(), Eq("ListModel"));
 }
 
 TEST_F(ListModelEditor, list_view_has_model_inside)

tests/unit/tests/unittests/metainfo/nodemetainfo-test.cpp

@@ -4,6 +4,7 @@
 #include "../utils/googletest.h"
 
 #include "../mocks/projectstoragemock.h"
+#include "../mocks/sourcepathcachemock.h"
 
 #include <designercore/include/model.h>
 #include <designercore/include/modelnode.h>
@@ -23,11 +24,17 @@ auto PropertyId(const Matcher &matcher)
 class NodeMetaInfo : public testing::Test
 {
 protected:
-    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock;
-    QmlDesigner::Model model{projectStorageMock, "QtQuick.Item"};
+    NiceMock<SourcePathCacheMockWithPaths> pathCache{"/path/foo.qml"};
+    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock{pathCache.sourceId};
+    QmlDesigner::Model model{{projectStorageMock, pathCache},
+                             "Item",
+                             {QmlDesigner::Import::createLibraryImport("QML"),
+                              QmlDesigner::Import::createLibraryImport("QtQuick"),
+                              QmlDesigner::Import::createLibraryImport("QtQml.Models")},
+                             QUrl::fromLocalFile(pathCache.path.toQString())};
     ModelNode rootNode = model.rootModelNode();
-    ModelNode item = model.createModelNode("QtQuick.Item");
-    ModelNode object = model.createModelNode("QML.QtObject");
+    ModelNode item = model.createModelNode("Item");
+    ModelNode object = model.createModelNode("QtObject");
     QmlDesigner::NodeMetaInfo itemMetaInfo = item.metaInfo();
     QmlDesigner::NodeMetaInfo objectMetaInfo = object.metaInfo();
     QmlDesigner::TypeId intTypeId = projectStorageMock.typeId(projectStorageMock.moduleId("QML"),
@@ -37,7 +44,7 @@ protected:
 
 TEST_F(NodeMetaInfo, is_true_if_meta_info_exists)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
 
     auto isValid = bool(metaInfo);
@@ -47,7 +54,7 @@ TEST_F(NodeMetaInfo, is_true_if_meta_info_exists)
 
 TEST_F(NodeMetaInfo, is_valid_if_meta_info_exists)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
 
     auto isValid = metaInfo.isValid();
@@ -57,7 +64,7 @@ TEST_F(NodeMetaInfo, is_valid_if_meta_info_exists)
 
 TEST_F(NodeMetaInfo, is_false_if_meta_info_not_exists)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto isValid = bool(metaInfo);
@@ -74,7 +81,7 @@ TEST_F(NodeMetaInfo, default_is_false)
 
 TEST_F(NodeMetaInfo, is_invalid_if_meta_info_not_exists)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto isValid = metaInfo.isValid();
@@ -126,7 +133,7 @@ TEST_F(NodeMetaInfo, default_is_not_file_component)
 
 TEST_F(NodeMetaInfo, invalid_is_not_file_component)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     bool isFileComponent = metaInfo.isFileComponent();
@@ -150,7 +157,7 @@ TEST_F(NodeMetaInfo, component_is_file_component)
 
 TEST_F(NodeMetaInfo, has_property)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     projectStorageMock.createProperty(metaInfo.id(), "x", intTypeId);
 
@@ -161,7 +168,7 @@ TEST_F(NodeMetaInfo, has_property)
 
 TEST_F(NodeMetaInfo, has_not_property)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
 
     bool hasProperty = metaInfo.hasProperty("foo");
@@ -180,7 +187,7 @@ TEST_F(NodeMetaInfo, default_has_not_property)
 
 TEST_F(NodeMetaInfo, invalid_has_not_property)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     bool hasProperty = metaInfo.hasProperty("x");
@@ -190,7 +197,7 @@ TEST_F(NodeMetaInfo, invalid_has_not_property)
 
 TEST_F(NodeMetaInfo, get_property)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     auto propertyId = projectStorageMock.createProperty(metaInfo.id(), "x", intTypeId);
 
@@ -201,7 +208,7 @@ TEST_F(NodeMetaInfo, get_property)
 
 TEST_F(NodeMetaInfo, get_invalid_property_if_not_exists)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
 
     auto property = metaInfo.property("x");
@@ -220,7 +227,7 @@ TEST_F(NodeMetaInfo, get_invalid_property_for_default)
 
 TEST_F(NodeMetaInfo, get_invalid_property_if_meta_info_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto property = metaInfo.property("x");
@@ -230,7 +237,7 @@ TEST_F(NodeMetaInfo, get_invalid_property_if_meta_info_is_invalid)
 
 TEST_F(NodeMetaInfo, get_properties)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     auto xPropertyId = projectStorageMock.createProperty(metaInfo.id(), "x", intTypeId);
     auto yPropertyId = projectStorageMock.createProperty(metaInfo.id(), "y", intTypeId);
@@ -251,7 +258,7 @@ TEST_F(NodeMetaInfo, get_no_properties_for_default)
 
 TEST_F(NodeMetaInfo, get_no_properties_if_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto properties = metaInfo.properties();
@@ -261,7 +268,7 @@ TEST_F(NodeMetaInfo, get_no_properties_if_is_invalid)
 
 TEST_F(NodeMetaInfo, get_local_properties)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     auto xPropertyId = projectStorageMock.createProperty(metaInfo.id(), "x", intTypeId);
     auto yPropertyId = projectStorageMock.createProperty(metaInfo.id(), "y", intTypeId);
@@ -282,7 +289,7 @@ TEST_F(NodeMetaInfo, get_no_local_properties_for_default_metainfo)
 
 TEST_F(NodeMetaInfo, get_no_local_properties_if_node_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto properties = metaInfo.localProperties();
@@ -292,7 +299,7 @@ TEST_F(NodeMetaInfo, get_no_local_properties_if_node_is_invalid)
 
 TEST_F(NodeMetaInfo, get_signal_names)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     projectStorageMock.createSignal(metaInfo.id(), "xChanged");
     projectStorageMock.createSignal(metaInfo.id(), "yChanged");
@@ -313,7 +320,7 @@ TEST_F(NodeMetaInfo, get_no_signal_names_for_default_metainfo)
 
 TEST_F(NodeMetaInfo, get_no_signal_names_if_node_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto signalNames = metaInfo.signalNames();
@@ -323,7 +330,7 @@ TEST_F(NodeMetaInfo, get_no_signal_names_if_node_is_invalid)
 
 TEST_F(NodeMetaInfo, get_function_names)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     projectStorageMock.createFunction(metaInfo.id(), "setX");
     projectStorageMock.createFunction(metaInfo.id(), "setY");
@@ -344,7 +351,7 @@ TEST_F(NodeMetaInfo, get_no_function_names_for_default_metainfo)
 
 TEST_F(NodeMetaInfo, get_no_function_names_if_node_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto functionNames = metaInfo.slotNames();
@@ -354,7 +361,7 @@ TEST_F(NodeMetaInfo, get_no_function_names_if_node_is_invalid)
 
 TEST_F(NodeMetaInfo, get_default_property)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     auto defaultProperty = metaInfo.property("data");
 
@@ -374,7 +381,7 @@ TEST_F(NodeMetaInfo, get_no_default_property_for_default_metainfo)
 
 TEST_F(NodeMetaInfo, get_no_default_property_if_node_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto property = metaInfo.defaultProperty();
@@ -384,7 +391,7 @@ TEST_F(NodeMetaInfo, get_no_default_property_if_node_is_invalid)
 
 TEST_F(NodeMetaInfo, get_default_property_name)
 {
-    auto node = model.createModelNode("QtQuick.Item");
+    auto node = model.createModelNode("Item");
     auto metaInfo = node.metaInfo();
     auto defaultProperty = metaInfo.property("data");
 
@@ -404,7 +411,7 @@ TEST_F(NodeMetaInfo, get_no_default_property_name_for_default_metainfo)
 
 TEST_F(NodeMetaInfo, get_no_default_property_name_if_node_is_invalid)
 {
-    auto node = model.createModelNode("QtQuick.Foo");
+    auto node = model.createModelNode("Foo");
     auto metaInfo = node.metaInfo();
 
     auto property = metaInfo.defaultPropertyName();

tests/unit/tests/unittests/model/model-test.cpp

@@ -3,15 +3,18 @@
 
 #include "../utils/googletest.h"
 
-#include "../mocks/mocklistmodeleditorview.h"
-#include "../mocks/modelresourcemanagementmock.h"
-#include "../mocks/projectstoragemock.h"
+#include <matchers/import-matcher.h>
+#include <mocks/mocklistmodeleditorview.h>
+#include <mocks/modelresourcemanagementmock.h>
+#include <mocks/projectstoragemock.h>
+#include <mocks/sourcepathcachemock.h>
 
 #include <designercore/include/bindingproperty.h>
 #include <designercore/include/model.h>
 #include <designercore/include/modelnode.h>
 #include <designercore/include/nodeabstractproperty.h>
 #include <designercore/include/nodelistproperty.h>
+#include <designercore/include/nodemetainfo.h>
 #include <designercore/include/nodeproperty.h>
 #include <designercore/include/signalhandlerproperty.h>
 #include <designercore/include/variantproperty.h>
@@ -22,12 +25,6 @@ using QmlDesigner::ModelNode;
 using QmlDesigner::ModelNodes;
 using QmlDesigner::ModelResourceSet;
 
-template<typename Matcher>
-auto HasPropertyName(const Matcher &matcher)
-{
-    return Property(&AbstractProperty::name, matcher);
-}
-
 MATCHER(IsSorted, std::string(negation ? "isn't sorted" : "is sorted"))
 {
     using std::begin;
@@ -40,14 +37,16 @@ class Model : public ::testing::Test
 protected:
     Model()
     {
+        model.setFileUrl(QUrl::fromLocalFile(pathCacheMock.path.toQString()));
         model.attachView(&viewMock);
         rootNode = viewMock.rootModelNode();
         ON_CALL(resourceManagementMock, removeNodes(_, _)).WillByDefault([](auto nodes, auto) {
             return ModelResourceSet{std::move(nodes), {}, {}};
         });
-        ON_CALL(resourceManagementMock, removeProperties(_, _)).WillByDefault([](auto properties, auto) {
-            return ModelResourceSet{{}, std::move(properties), {}};
-        });
+        ON_CALL(resourceManagementMock, removeProperties(_, _))
+            .WillByDefault([](auto properties, auto) {
+                return ModelResourceSet{{}, std::move(properties), {}};
+            });
     }
 
     ~Model() { model.detachView(&viewMock); }
@@ -79,15 +78,23 @@ protected:
 
 protected:
     NiceMock<MockListModelEditorView> viewMock;
-    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock;
+    NiceMock<SourcePathCacheMockWithPaths> pathCacheMock{"/path/foo.qml"};
+    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock{pathCacheMock.sourceId};
     NiceMock<ModelResourceManagementMock> resourceManagementMock;
-    QmlDesigner::Model model{projectStorageMock,
-                             "QtQuick.Item",
+    QmlDesigner::Model model{{projectStorageMock, pathCacheMock},
+                             "Item",
                              -1,
                              -1,
                              nullptr,
                              std::make_unique<ModelResourceManagementMockWrapper>(
                                  resourceManagementMock)};
+    QmlDesigner::SourceId filePathId = pathCacheMock.sourceId;
+    QmlDesigner::TypeId itemTypeId = projectStorageMock.typeId(projectStorageMock.moduleId(
+                                                                   "QtQuick"),
+                                                               "Item",
+                                                               QmlDesigner::Storage::Version{});
+    QmlDesigner::ImportedTypeNameId itemTypeNameId = projectStorageMock.createImportedTypeNameId(
+        filePathId, "Item", itemTypeId);
     ModelNode rootNode;
 };
 
@@ -473,7 +480,7 @@ TEST_F(Model,
 TEST_F(Model, by_default_remove_model_node_removes_node)
 {
     model.detachView(&viewMock);
-    QmlDesigner::Model newModel{projectStorageMock, "QtQuick.Item"};
+    QmlDesigner::Model newModel{{projectStorageMock, pathCacheMock}, "QtQuick.Item"};
     newModel.attachView(&viewMock);
     auto node = createNodeWithParent(viewMock.rootModelNode());
 
@@ -485,7 +492,7 @@ TEST_F(Model, by_default_remove_model_node_removes_node)
 TEST_F(Model, by_default_remove_properties_removes_property)
 {
     model.detachView(&viewMock);
-    QmlDesigner::Model newModel{projectStorageMock, "QtQuick.Item"};
+    QmlDesigner::Model newModel{{projectStorageMock, pathCacheMock}, "QtQuick.Item"};
     newModel.attachView(&viewMock);
     rootNode = viewMock.rootModelNode();
     auto property = createProperty(rootNode, "yi");
@@ -498,7 +505,7 @@ TEST_F(Model, by_default_remove_properties_removes_property)
 TEST_F(Model, by_default_remove_model_node_in_factory_method_calls_removes_node)
 {
     model.detachView(&viewMock);
-    auto newModel = QmlDesigner::Model::create(projectStorageMock, "QtQuick.Item");
+    auto newModel = QmlDesigner::Model::create({projectStorageMock, pathCacheMock}, "QtQuick.Item");
     newModel->attachView(&viewMock);
     auto node = createNodeWithParent(viewMock.rootModelNode());
 
@@ -510,7 +517,7 @@ TEST_F(Model, by_default_remove_model_node_in_factory_method_calls_removes_node)
 TEST_F(Model, by_default_remove_properties_in_factory_method_calls_remove_property)
 {
     model.detachView(&viewMock);
-    auto newModel = QmlDesigner::Model::create(projectStorageMock, "QtQuick.Item");
+    auto newModel = QmlDesigner::Model::create({projectStorageMock, pathCacheMock}, "QtQuick.Item");
     newModel->attachView(&viewMock);
     rootNode = viewMock.rootModelNode();
     auto property = createProperty(rootNode, "yi");
@@ -602,7 +609,7 @@ TEST_F(Model, remove_model_nodes_bypasses_model_resource_management)
 TEST_F(Model, by_default_remove_model_nodes_in_factory_method_calls_removes_node)
 {
     model.detachView(&viewMock);
-    QmlDesigner::Model newModel{projectStorageMock, "QtQuick.Item"};
+    QmlDesigner::Model newModel{{projectStorageMock, pathCacheMock}, "QtQuick.Item"};
     newModel.attachView(&viewMock);
     rootNode = viewMock.rootModelNode();
     auto node = createNodeWithParent(rootNode, "yi");
@@ -695,7 +702,7 @@ TEST_F(Model, remove_properties_bypasses_model_resource_management)
 TEST_F(Model, by_default_remove_properties_in_factory_method_calls_removes_properties)
 {
     model.detachView(&viewMock);
-    QmlDesigner::Model newModel{projectStorageMock, "QtQuick.Item"};
+    QmlDesigner::Model newModel{{projectStorageMock, pathCacheMock}, "QtQuick.Item"};
     newModel.attachView(&viewMock);
     rootNode = viewMock.rootModelNode();
     auto property = createProperty(rootNode, "yi");
@@ -706,4 +713,146 @@ TEST_F(Model, by_default_remove_properties_in_factory_method_calls_removes_prope
     newModel.removeProperties({property, property2});
 }
 
+TEST_F(Model, change_imports_is_synchronizing_imports_with_project_storage)
+{
+    QmlDesigner::SourceId directoryPathId = QmlDesigner::SourceId::create(2);
+    ON_CALL(pathCacheMock, sourceId(Eq("/path/foo/."))).WillByDefault(Return(directoryPathId));
+    auto qtQuickModuleId = projectStorageMock.moduleId("QtQuick");
+    auto qtQmlModelsModuleId = projectStorageMock.moduleId("QtQml.Models");
+    auto qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "2.1");
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models");
+    auto directoryImport = QmlDesigner::Import::createFileImport("foo");
+
+    EXPECT_CALL(projectStorageMock,
+                synchronizeDocumentImports(
+                    UnorderedElementsAre(IsImport(qtQuickModuleId, filePathId, 2, 1),
+                                         IsImport(qtQmlModelsModuleId, filePathId, -1, -1)),
+                    filePathId));
+
+    model.changeImports({qtQuickImport, qtQmlModelsImport}, {});
+}
+
+TEST_F(Model,
+       change_imports_is_not_synchronizing_imports_with_project_storage_if_no_new_imports_are_added)
+{
+    QmlDesigner::SourceId directoryPathId = QmlDesigner::SourceId::create(2);
+    ON_CALL(pathCacheMock, sourceId(Eq("/path/foo/."))).WillByDefault(Return(directoryPathId));
+    auto qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "2.1");
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models");
+    auto directoryImport = QmlDesigner::Import::createFileImport("foo");
+    model.changeImports({qtQuickImport, qtQmlModelsImport}, {});
+
+    EXPECT_CALL(projectStorageMock, synchronizeDocumentImports(_, _)).Times(0);
+
+    model.changeImports({qtQuickImport, qtQmlModelsImport}, {});
+}
+
+TEST_F(Model, change_imports_is_adding_import_in_project_storage)
+{
+    QmlDesigner::SourceId directoryPathId = QmlDesigner::SourceId::create(2);
+    ON_CALL(pathCacheMock, sourceId(Eq("/path/foo/."))).WillByDefault(Return(directoryPathId));
+    auto qtQuickModuleId = projectStorageMock.moduleId("QtQuick");
+    auto qtQmlModelsModuleId = projectStorageMock.moduleId("QtQml.Models");
+    auto qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "2.1");
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models");
+    auto directoryImport = QmlDesigner::Import::createFileImport("foo");
+    model.changeImports({qtQmlModelsImport}, {});
+
+    EXPECT_CALL(projectStorageMock,
+                synchronizeDocumentImports(
+                    UnorderedElementsAre(IsImport(qtQuickModuleId, filePathId, 2, 1),
+                                         IsImport(qtQmlModelsModuleId, filePathId, -1, -1)),
+                    filePathId));
+
+    model.changeImports({qtQuickImport}, {});
+}
+
+TEST_F(Model, change_imports_is_removing_import_in_project_storage)
+{
+    QmlDesigner::SourceId directoryPathId = QmlDesigner::SourceId::create(2);
+    ON_CALL(pathCacheMock, sourceId(Eq("/path/foo/."))).WillByDefault(Return(directoryPathId));
+    auto qtQmlModelsModuleId = projectStorageMock.moduleId("QtQml.Models");
+    auto qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "2.1");
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models");
+    auto directoryImport = QmlDesigner::Import::createFileImport("foo");
+    model.changeImports({qtQuickImport, qtQmlModelsImport}, {});
+
+    EXPECT_CALL(projectStorageMock,
+                synchronizeDocumentImports(UnorderedElementsAre(
+                                               IsImport(qtQmlModelsModuleId, filePathId, -1, -1)),
+                                           filePathId));
+
+    model.changeImports({}, {qtQuickImport});
+}
+
+TEST_F(Model,
+       change_imports_is_not_removing_import_in_project_storage_if_import_is_not_in_model_imports)
+{
+    QmlDesigner::SourceId directoryPathId = QmlDesigner::SourceId::create(2);
+    ON_CALL(pathCacheMock, sourceId(Eq("/path/foo/."))).WillByDefault(Return(directoryPathId));
+    auto qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "2.1");
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models");
+    auto directoryImport = QmlDesigner::Import::createFileImport("foo");
+    model.changeImports({qtQuickImport}, {});
+
+    EXPECT_CALL(projectStorageMock, synchronizeDocumentImports(_, _)).Times(0);
+
+    model.changeImports({}, {qtQmlModelsImport});
+}
+
+TEST_F(Model, change_imports_is_changing_import_version_with_project_storage)
+{
+    QmlDesigner::SourceId directoryPathId = QmlDesigner::SourceId::create(2);
+    ON_CALL(pathCacheMock, sourceId(Eq("/path/foo/."))).WillByDefault(Return(directoryPathId));
+    auto qtQuickModuleId = projectStorageMock.moduleId("QtQuick");
+    auto qtQmlModelsModuleId = projectStorageMock.moduleId("QtQml.Models");
+    auto qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "2.1");
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models");
+    auto directoryImport = QmlDesigner::Import::createFileImport("foo");
+    model.changeImports({qtQuickImport, qtQmlModelsImport}, {});
+    qtQuickImport = QmlDesigner::Import::createLibraryImport("QtQuick", "3.1");
+
+    EXPECT_CALL(projectStorageMock,
+                synchronizeDocumentImports(
+                    UnorderedElementsAre(IsImport(qtQuickModuleId, filePathId, 3, 1),
+                                         IsImport(qtQmlModelsModuleId, filePathId, -1, -1)),
+                    filePathId));
+
+    model.changeImports({qtQuickImport}, {});
+}
+
+TEST_F(Model, create_model_node_has_meta_info)
+{
+    auto node = model.createModelNode("Item");
+
+    ASSERT_THAT(node.metaInfo(), model.qtQuickItemMetaInfo());
+}
+
+TEST_F(Model, create_qualified_model_node_has_meta_info)
+{
+    auto qtQmlModelsImport = QmlDesigner::Import::createLibraryImport("QtQml.Models", "", "Foo");
+    auto qtQmlModelsModulesId = projectStorageMock.moduleId("QtQml.Models");
+    auto importId = projectStorageMock.createImportId(qtQmlModelsModulesId, filePathId);
+    auto listModelTypeId = projectStorageMock.typeId(qtQmlModelsModulesId,
+                                                     "ListModel",
+                                                     QmlDesigner::Storage::Version{});
+    projectStorageMock.createImportedTypeNameId(importId, "ListModel", listModelTypeId);
+    model.changeImports({qtQmlModelsImport}, {});
+
+    auto node = model.createModelNode("Foo.ListModel");
+
+    ASSERT_THAT(node.metaInfo(), model.qtQmlModelsListModelMetaInfo());
+}
+
+TEST_F(Model, change_root_node_type_changes_meta_info)
+{
+    projectStorageMock.createImportedTypeNameId(filePathId,
+                                                "QtObject",
+                                                model.qmlQtObjectMetaInfo().id());
+
+    model.changeRootNodeType("QtObject");
+
+    ASSERT_THAT(rootNode.metaInfo(), model.qmlQtObjectMetaInfo());
+}
+
 } // namespace

tests/unit/tests/unittests/model/modelnode-test.cpp

@@ -4,6 +4,7 @@
 #include "../utils/googletest.h"
 
 #include "../mocks/projectstoragemock.h"
+#include "../mocks/sourcepathcachemock.h"
 
 #include <designercore/include/model.h>
 #include <designercore/include/modelnode.h>
@@ -14,8 +15,9 @@ namespace {
 class ModelNode : public testing::Test
 {
 protected:
-    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock;
-    QmlDesigner::Model model{projectStorageMock, "QtQuick.Item"};
+    NiceMock<SourcePathCacheMockWithPaths> pathCache{"/path/foo.qml"};
+    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock{pathCache.sourceId};
+    QmlDesigner::Model model{{projectStorageMock, pathCache}, "Item"};
     QmlDesigner::ModelNode rootNode = model.rootModelNode();
 };
 

tests/unit/tests/unittests/model/modelresourcemanagement-test.cpp

@@ -6,6 +6,7 @@
 #include "../mocks/mocklistmodeleditorview.h"
 #include "../mocks/modelresourcemanagementmock.h"
 #include "../mocks/projectstoragemock.h"
+#include "../mocks/sourcepathcachemock.h"
 
 #include <include/bindingproperty.h>
 #include <include/model.h>
@@ -70,9 +71,13 @@ protected:
 
 protected:
     NiceMock<MockListModelEditorView> viewMock;
-    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock;
+    NiceMock<SourcePathCacheMockWithPaths> pathCacheMock{"/path/foo.qml"};
+    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock{pathCacheMock.sourceId};
     QmlDesigner::ModelResourceManagement management;
-    QmlDesigner::Model model{projectStorageMock, "QtQuick.Item"};
+    QmlDesigner::Model model{{projectStorageMock, pathCacheMock},
+                             "Item",
+                             {QmlDesigner::Import::createLibraryImport("QtQtuick")},
+                             QUrl::fromLocalFile(pathCacheMock.path.toQString())};
     ModelNode rootNode;
 };
 

tests/unit/tests/unittests/model/nodelistproperty-test.cpp

@@ -4,6 +4,7 @@
 #include <abstractviewmock.h>
 #include <googletest.h>
 #include <projectstoragemock.h>
+#include <sourcepathcachemock.h>
 
 #include <model.h>
 #include <modelnode.h>
@@ -77,9 +78,14 @@ protected:
     }
 
 protected:
-    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock;
-    std::unique_ptr<QmlDesigner::Model> model{
-        std::make_unique<QmlDesigner::Model>(projectStorageMock, "QtQuick.Item")};
+    NiceMock<SourcePathCacheMockWithPaths> pathCache{"/path/foo.qml"};
+    NiceMock<ProjectStorageMockWithQtQtuick> projectStorageMock{pathCache.sourceId};
+    QmlDesigner::ModelPointer model{
+        QmlDesigner::Model::create(QmlDesigner::ProjectStorageDependencies{projectStorageMock,
+                                                                           pathCache},
+                                   "Item",
+                                   {QmlDesigner::Import::createLibraryImport("QtQuick")},
+                                   QUrl::fromLocalFile(pathCache.path.toQString()))};
     NiceMock<AbstractViewMock> abstractViewMock;
     QmlDesigner::NodeListProperty nodeListProperty;
     ModelNode node1;

tests/unit/tests/unittests/projectstorage/projectstorage-test.cpp

@@ -29,10 +29,10 @@ using QmlDesigner::Storage::Synchronization::SynchronizationPackage;
 
 namespace Storage = QmlDesigner::Storage;
 
-Storage::Synchronization::Imports operator+(const Storage::Synchronization::Imports &first,
-                                            const Storage::Synchronization::Imports &second)
+Storage::Imports operator+(const Storage::Imports &first,
+                                            const Storage::Imports &second)
 {
-    Storage::Synchronization::Imports imports;
+    Storage::Imports imports;
     imports.reserve(first.size() + second.size());
 
     imports.insert(imports.end(), first.begin(), first.end());
@@ -1039,16 +1039,16 @@ protected:
     ModuleId qtQuick3DModuleId{storage.moduleId("QtQuick3D")};
     ModuleId myModuleModuleId{storage.moduleId("MyModule")};
     ModuleId QMLModuleId{storage.moduleId("QML")};
-    Storage::Synchronization::Imports importsSourceId1;
-    Storage::Synchronization::Imports importsSourceId2;
-    Storage::Synchronization::Imports importsSourceId3;
-    Storage::Synchronization::Imports importsSourceId4;
-    Storage::Synchronization::Imports importsSourceId5;
-    Storage::Synchronization::Imports moduleDependenciesSourceId1;
-    Storage::Synchronization::Imports moduleDependenciesSourceId2;
-    Storage::Synchronization::Imports moduleDependenciesSourceId3;
-    Storage::Synchronization::Imports moduleDependenciesSourceId4;
-    Storage::Synchronization::Imports moduleDependenciesSourceId5;
+    Storage::Imports importsSourceId1;
+    Storage::Imports importsSourceId2;
+    Storage::Imports importsSourceId3;
+    Storage::Imports importsSourceId4;
+    Storage::Imports importsSourceId5;
+    Storage::Imports moduleDependenciesSourceId1;
+    Storage::Imports moduleDependenciesSourceId2;
+    Storage::Imports moduleDependenciesSourceId3;
+    Storage::Imports moduleDependenciesSourceId4;
+    Storage::Imports moduleDependenciesSourceId5;
 };
 
 TEST_F(ProjectStorage, fetch_source_context_id_returns_always_the_same_id_for_the_same_path)
@@ -1438,7 +1438,7 @@ TEST_F(ProjectStorage, synchronize_types_overwrites_sources)
     storage.synchronize(package);
     package.types[0].sourceId = sourceId3;
     package.types[1].sourceId = sourceId4;
-    Storage::Synchronization::Imports newImports;
+    Storage::Imports newImports;
     newImports.emplace_back(qmlModuleId, Storage::Version{}, sourceId3);
     newImports.emplace_back(qmlNativeModuleId, Storage::Version{}, sourceId3);
     newImports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId3);
@@ -1558,10 +1558,7 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_prototype)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(Storage::Synchronization::Type{
         "QQuickObject",
         Storage::Synchronization::ImportedType{"QObject"},
@@ -1604,10 +1601,7 @@ TEST_F(ProjectStorage, synchronize_types_add_qualified_extension)
     auto package{createSimpleSynchronizationPackage()};
     swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(Storage::Synchronization::Type{
         "QQuickObject",
         Storage::Synchronization::ImportedType{},
@@ -1826,10 +1820,7 @@ TEST_F(ProjectStorage, synchronize_types_add_property_declaration_qualified_type
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{"QObject"},
@@ -2016,10 +2007,7 @@ TEST_F(ProjectStorage, using_non_existing_qualified_exported_property_type_with_
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "QObject2",
-        Storage::Synchronization::Import{qmlNativeModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "QObject2", Storage::Import{qmlNativeModuleId, Storage::Version{}, sourceId1}};
     package.types.pop_back();
     package.imports = importsSourceId1;
 
@@ -2030,8 +2018,7 @@ TEST_F(ProjectStorage, using_non_existing_qualified_exported_property_type_with_
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "QObject",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "QObject", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.pop_back();
     package.imports = importsSourceId1;
 
@@ -3281,8 +3268,7 @@ TEST_F(ProjectStorage, do_not_relink_alias_property_for_qualified_imported_type_
 {
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object2",
-        Storage::Synchronization::Import{pathToModuleId, Storage::Version{}, sourceId2}};
+        "Object2", Storage::Import{pathToModuleId, Storage::Version{}, sourceId2}};
     package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
     storage.synchronize(package);
     package.types[3].exportedTypes[0].moduleId = qtQuickModuleId;
@@ -3298,8 +3284,7 @@ TEST_F(ProjectStorage,
 {
     auto package{createSynchronizationPackageWithAliases()};
     package.types[1].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object2",
-        Storage::Synchronization::Import{pathToModuleId, Storage::Version{}, sourceId2}};
+        "Object2", Storage::Import{pathToModuleId, Storage::Version{}, sourceId2}};
     package.imports.emplace_back(pathToModuleId, Storage::Version{}, sourceId2);
     package.types.push_back(Storage::Synchronization::Type{
         "QObject2",
@@ -3522,8 +3507,7 @@ TEST_F(ProjectStorage, change_qualified_prototype_type_module_id_throws)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -3537,8 +3521,7 @@ TEST_F(ProjectStorage, change_qualified_extension_type_module_id_throws)
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -3551,15 +3534,11 @@ TEST_F(ProjectStorage, change_qualified_prototype_type_module_id)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
 
     storage.synchronize(SynchronizationPackage{importsSourceId1 + importsSourceId2,
                                                {package.types[0], package.types[1]},
@@ -3578,15 +3557,11 @@ TEST_F(ProjectStorage, change_qualified_extension_type_module_id)
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
 
     storage.synchronize(SynchronizationPackage{importsSourceId1 + importsSourceId2,
                                                {package.types[0], package.types[1]},
@@ -3926,8 +3901,7 @@ TEST_F(ProjectStorage, qualified_prototype)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -3954,8 +3928,7 @@ TEST_F(ProjectStorage, qualified_extension)
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -3981,10 +3954,7 @@ TEST_F(ProjectStorage, qualified_prototype_upper_down_the_module_chain_throws)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
 }
@@ -3994,10 +3964,7 @@ TEST_F(ProjectStorage, qualified_extension_upper_down_the_module_chain_throws)
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
 }
@@ -4006,10 +3973,7 @@ TEST_F(ProjectStorage, qualified_prototype_upper_in_the_module_chain)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4036,10 +4000,7 @@ TEST_F(ProjectStorage, qualified_extension_upper_in_the_module_chain)
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4065,8 +4026,7 @@ TEST_F(ProjectStorage, qualified_prototype_with_wrong_version_throws)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{4}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{4}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4086,8 +4046,7 @@ TEST_F(ProjectStorage, qualified_extension_with_wrong_version_throws)
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{4}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{4}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4220,10 +4179,7 @@ TEST_F(ProjectStorage, qualified_prototype_with_version_down_the_proto_type_chai
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{2},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{2}, sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
 }
@@ -4233,10 +4189,7 @@ TEST_F(ProjectStorage, qualified_extension_with_version_down_the_proto_type_chai
     auto package{createSimpleSynchronizationPackage()};
     std::swap(package.types.front().extension, package.types.front().prototype);
     package.types[0].extension = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{2},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{2}, sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
 }
@@ -4245,8 +4198,7 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4272,10 +4224,7 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name_down_the_module_
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
 
     ASSERT_THROW(storage.synchronize(package), QmlDesigner::TypeNameDoesNotExists);
 }
@@ -4284,10 +4233,7 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name_in_the_module_ch
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types.push_back(
         Storage::Synchronization::Type{"QQuickObject",
                                        Storage::Synchronization::ImportedType{},
@@ -4313,8 +4259,7 @@ TEST_F(ProjectStorage, qualified_property_declaration_type_name_with_version)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{2}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{2}, sourceId1}};
     package.imports.emplace_back(qmlModuleId, Storage::Version{2}, sourceId1);
 
     storage.synchronize(package);
@@ -4331,8 +4276,7 @@ TEST_F(ProjectStorage, change_property_type_module_id_with_qualified_type_throws
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
 
@@ -4345,14 +4289,10 @@ TEST_F(ProjectStorage, change_property_type_module_id_with_qualified_type)
 {
     auto package{createSimpleSynchronizationPackage()};
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qmlModuleId, Storage::Version{}, sourceId1}};
+        "Object", Storage::Import{qmlModuleId, Storage::Version{}, sourceId1}};
     storage.synchronize(package);
     package.types[0].propertyDeclarations[0].typeName = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuickModuleId,
-                                         Storage::Version{},
-                                         sourceId1}};
+        "Object", Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1}};
     package.types[1].exportedTypes[0].moduleId = qtQuickModuleId;
     package.imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId2);
 
@@ -4476,9 +4416,7 @@ TEST_F(ProjectStorage, fetch_by_major_version_for_imported_type)
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4491,9 +4429,7 @@ TEST_F(ProjectStorage, fetch_by_major_version_for_qualified_imported_type)
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Object", import},
@@ -4524,9 +4460,7 @@ TEST_F(ProjectStorage, fetch_by_major_version_and_minor_version_for_imported_typ
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 2},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 2}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4539,9 +4473,7 @@ TEST_F(ProjectStorage, fetch_by_major_version_and_minor_version_for_qualified_im
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 2},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 2}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4573,9 +4505,7 @@ TEST_F(ProjectStorage,
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -4586,9 +4516,7 @@ TEST_F(ProjectStorage,
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Object", import},
@@ -4616,9 +4544,7 @@ TEST_F(ProjectStorage, fetch_low_minor_version_for_imported_type_throws)
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -4628,9 +4554,7 @@ TEST_F(ProjectStorage, fetch_low_minor_version_for_qualified_imported_type_throw
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 1}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4658,9 +4582,7 @@ TEST_F(ProjectStorage, fetch_higher_minor_version_for_imported_type)
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 3},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 3}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4673,9 +4595,7 @@ TEST_F(ProjectStorage, fetch_higher_minor_version_for_qualified_imported_type)
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{1, 3},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{1, 3}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4706,9 +4626,7 @@ TEST_F(ProjectStorage, fetch_different_major_version_for_imported_type_throws)
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{3, 1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{3, 1}, sourceId2};
 
     ASSERT_THROW(storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}}),
                  QmlDesigner::TypeNameDoesNotExists);
@@ -4718,9 +4636,7 @@ TEST_F(ProjectStorage, fetch_different_major_version_for_qualified_imported_type
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{3, 1},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{3, 1}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4748,9 +4664,7 @@ TEST_F(ProjectStorage, fetch_other_type_by_different_version_for_imported_type)
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{2, 3},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4763,9 +4677,7 @@ TEST_F(ProjectStorage, fetch_other_type_by_different_version_for_qualified_impor
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{2, 3},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4796,7 +4708,7 @@ TEST_F(ProjectStorage, fetch_highest_version_for_import_without_version_for_impo
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4809,7 +4721,7 @@ TEST_F(ProjectStorage, fetch_highest_version_for_import_without_version_for_qual
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4840,9 +4752,7 @@ TEST_F(ProjectStorage, fetch_highest_version_for_import_with_major_version_for_i
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{2},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{2}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4855,9 +4765,7 @@ TEST_F(ProjectStorage, fetch_highest_version_for_import_with_major_version_for_q
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId,
-                                            Storage::Version{2},
-                                            sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{2}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"Obj", import},
@@ -4888,7 +4796,7 @@ TEST_F(ProjectStorage, fetch_exported_type_without_version_first_for_imported_ty
         {Storage::Synchronization::ExportedType{qtQuickModuleId,
                                                 "Item",
                                                 Storage::Version{}}}};
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
 
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId2}});
 
@@ -4901,7 +4809,7 @@ TEST_F(ProjectStorage, fetch_exported_type_without_version_first_for_qualified_i
 {
     auto package{createSynchronizationPackageWithVersions()};
     storage.synchronize(package);
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId2};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId2};
     Storage::Synchronization::Type type{
         "Item",
         Storage::Synchronization::QualifiedImportedType{"BuiltInObj", import},
@@ -4934,7 +4842,7 @@ TEST_F(ProjectStorage, ensure_that_properties_for_removed_types_are_not_anymore_
                                                        Storage::Synchronization::ImportedType{
                                                            "Object"},
                                                        Storage::PropertyDeclarationTraits::IsList}}};
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{}, sourceId1};
+    Storage::Import import{qmlModuleId, Storage::Version{}, sourceId1};
     storage.synchronize(SynchronizationPackage{{import}, {type}, {sourceId1}});
 
     ASSERT_NO_THROW(storage.synchronize(SynchronizationPackage{{sourceId1}}));
@@ -5515,10 +5423,7 @@ TEST_F(ProjectStorage, module_exported_import_with_qualified_imported_type)
 {
     auto package{createModuleExportedImportSynchronizationPackage()};
     package.types.back().prototype = Storage::Synchronization::QualifiedImportedType{
-        "Object",
-        Storage::Synchronization::Import{qtQuick3DModuleId,
-                                         Storage::Version{1},
-                                         sourceId4}};
+        "Object", Storage::Import{qtQuick3DModuleId, Storage::Version{1}, sourceId4}};
 
     storage.synchronize(std::move(package));
 
@@ -6901,4 +6806,139 @@ TEST_F(ProjectStorage, is_not_based_on_if_no_base_type_is_given)
     ASSERT_FALSE(isBasedOn);
 }
 
+TEST_F(ProjectStorage, get_imported_type_name_id_for_source_id)
+{
+    auto sourceId = sourcePathCache.sourceId("/path/foo.qml");
+
+    auto importedTypeNameId = storage.importedTypeNameId(sourceId, "Item");
+
+    ASSERT_TRUE(importedTypeNameId);
+}
+
+TEST_F(ProjectStorage,
+       get_imported_type_name_id_for_source_id_returns_the_same_id_for_the_same_arguments)
+{
+    auto sourceId = sourcePathCache.sourceId("/path/foo.qml");
+    auto expectedImportedTypeNameId = storage.importedTypeNameId(sourceId, "Item");
+
+    auto importedTypeNameId = storage.importedTypeNameId(sourceId, "Item");
+
+    ASSERT_THAT(importedTypeNameId, expectedImportedTypeNameId);
+}
+
+TEST_F(ProjectStorage,
+       get_imported_type_name_id_for_source_id_returns_different_id_for_different_sourceId)
+{
+    auto sourceId = sourcePathCache.sourceId("/path/foo.qml");
+    auto expectedImportedTypeNameId = storage.importedTypeNameId(sourceId, "Item");
+    auto sourceId2 = sourcePathCache.sourceId("/path/foo2.qml");
+
+    auto importedTypeNameId = storage.importedTypeNameId(sourceId2, "Item");
+
+    ASSERT_THAT(importedTypeNameId, Not(expectedImportedTypeNameId));
+}
+
+TEST_F(ProjectStorage, get_imported_type_name_id_returns_different_id_for_different_name)
+{
+    auto sourceId = sourcePathCache.sourceId("/path/foo.qml");
+    auto expectedImportedTypeNameId = storage.importedTypeNameId(sourceId, "Item");
+
+    auto importedTypeNameId = storage.importedTypeNameId(sourceId, "Item2");
+
+    ASSERT_THAT(importedTypeNameId, Not(expectedImportedTypeNameId));
+}
+
+TEST_F(ProjectStorage, get_import_id)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    storage.synchronize(package);
+
+    auto importId = storage.importId(Storage::Import{qmlModuleId, Storage::Version{}, sourceId1});
+
+    ASSERT_TRUE(importId);
+}
+
+TEST_F(ProjectStorage, get_invalid_import_id_if_not_exists)
+{
+    auto importId = storage.importId(Storage::Import{qmlModuleId, Storage::Version{}, sourceId1});
+
+    ASSERT_FALSE(importId);
+}
+
+TEST_F(ProjectStorage, get_imported_type_name_id_for_import_id)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    storage.synchronize(package);
+    auto importId = storage.importId(Storage::Import{qmlModuleId, Storage::Version{}, sourceId1});
+
+    auto importedTypeNameId = storage.importedTypeNameId(importId, "Item");
+
+    ASSERT_TRUE(importedTypeNameId);
+}
+
+TEST_F(ProjectStorage,
+       get_imported_type_name_id_for_import_id_returns_different_id_for_different_importId)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    storage.synchronize(package);
+    auto importId = storage.importId(Storage::Import{qmlModuleId, Storage::Version{}, sourceId1});
+    auto expectedImportedTypeNameId = storage.importedTypeNameId(importId, "Item");
+    auto importId2 = storage.importId(
+        Storage::Import{qtQuickModuleId, Storage::Version{}, sourceId1});
+
+    auto importedTypeNameId = storage.importedTypeNameId(importId2, "Item");
+
+    ASSERT_THAT(importedTypeNameId, Not(expectedImportedTypeNameId));
+}
+
+TEST_F(ProjectStorage,
+       get_imported_type_name_id_for_import_id_returns_different_id_for_different_name)
+{
+    auto package{createSimpleSynchronizationPackage()};
+    storage.synchronize(package);
+    auto importId = storage.importId(Storage::Import{qmlModuleId, Storage::Version{}, sourceId1});
+    auto expectedImportedTypeNameId = storage.importedTypeNameId(importId, "Item");
+
+    auto importedTypeNameId = storage.importedTypeNameId(importId, "Item2");
+
+    ASSERT_THAT(importedTypeNameId, Not(expectedImportedTypeNameId));
+}
+
+TEST_F(ProjectStorage, synchronize_document_imports)
+{
+    Storage::Imports imports;
+    imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+
+    storage.synchronizeDocumentImports(imports, sourceId1);
+
+    ASSERT_TRUE(storage.importId(imports.back()));
+}
+
+TEST_F(ProjectStorage, synchronize_document_imports_removes_import)
+{
+    Storage::Imports imports;
+    imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+    storage.synchronizeDocumentImports(imports, sourceId1);
+    auto removedImport = imports.back();
+    imports.pop_back();
+
+    storage.synchronizeDocumentImports(imports, sourceId1);
+
+    ASSERT_FALSE(storage.importId(removedImport));
+}
+
+TEST_F(ProjectStorage, synchronize_document_imports_adds_import)
+{
+    Storage::Imports imports;
+    imports.emplace_back(qmlModuleId, Storage::Version{}, sourceId1);
+    storage.synchronizeDocumentImports(imports, sourceId1);
+    imports.emplace_back(qtQuickModuleId, Storage::Version{}, sourceId1);
+
+    storage.synchronizeDocumentImports(imports, sourceId1);
+
+    ASSERT_TRUE(storage.importId(imports.back()));
+}
+
 } // namespace

tests/unit/tests/unittests/projectstorage/projectstorageupdater-test.cpp

@@ -24,14 +24,14 @@ using QmlDesigner::ModuleId;
 using QmlDesigner::SourceId;
 namespace Storage = QmlDesigner::Storage;
 using QmlDesigner::IdPaths;
-using QmlDesigner::Storage::TypeTraits;
-using QmlDesigner::Storage::Version;
+using QmlDesigner::Storage::Import;
 using QmlDesigner::Storage::Synchronization::FileType;
-using QmlDesigner::Storage::Synchronization::Import;
 using QmlDesigner::Storage::Synchronization::IsAutoVersion;
 using QmlDesigner::Storage::Synchronization::ModuleExportedImport;
 using QmlDesigner::Storage::Synchronization::ProjectData;
 using QmlDesigner::Storage::Synchronization::SynchronizationPackage;
+using QmlDesigner::Storage::TypeTraits;
+using QmlDesigner::Storage::Version;
 
 MATCHER_P5(IsStorageType,
            typeName,
@@ -327,11 +327,11 @@ protected:
     Storage::Synchronization::Type firstType;
     Storage::Synchronization::Type secondType;
     Storage::Synchronization::Type thirdType;
-    Storage::Synchronization::Import import1{qmlModuleId, Storage::Version{2, 3}, qmlDocumentSourceId1};
-    Storage::Synchronization::Import import2{qmlModuleId, Storage::Version{}, qmlDocumentSourceId2};
-    Storage::Synchronization::Import import3{qmlModuleId, Storage::Version{2}, qmlDocumentSourceId3};
-    Storage::Synchronization::Import import4{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
-    Storage::Synchronization::Import import5{qmlModuleId, Storage::Version{2, 3}, qmltypes2PathSourceId};
+    Storage::Import import1{qmlModuleId, Storage::Version{2, 3}, qmlDocumentSourceId1};
+    Storage::Import import2{qmlModuleId, Storage::Version{}, qmlDocumentSourceId2};
+    Storage::Import import3{qmlModuleId, Storage::Version{2}, qmlDocumentSourceId3};
+    Storage::Import import4{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
+    Storage::Import import5{qmlModuleId, Storage::Version{2, 3}, qmltypes2PathSourceId};
     QString qmldirContent{"module Example\ntypeinfo example.qmltypes\n"};
     QString qmltypes1{"Module {\ndependencies: [module1]}"};
     QString qmltypes2{"Module {\ndependencies: [module2]}"};
@@ -445,7 +445,7 @@ TEST_F(ProjectStorageUpdater, synchronize_is_empty_for_no_change)
 
 TEST_F(ProjectStorageUpdater, synchronize_qml_types)
 {
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
     QString qmltypes{"Module {\ndependencies: []}"};
     setQmlFileNames(u"/path", {});
     setContent(u"/path/example.qmltypes", qmltypes);
@@ -480,7 +480,7 @@ TEST_F(ProjectStorageUpdater, synchronize_qml_types)
 
 TEST_F(ProjectStorageUpdater, synchronize_qml_types_throws_if_qmltpes_does_not_exists)
 {
-    Storage::Synchronization::Import import{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
+    Storage::Import import{qmlModuleId, Storage::Version{2, 3}, qmltypesPathSourceId};
     setFilesDontExists({qmltypesPathSourceId});
 
     ASSERT_THROW(updater.update(directories, {}), QmlDesigner::CannotParseQmlTypesFile);

tests/unit/tests/unittests/projectstorage/qmldocumentparser-test.cpp

@@ -11,16 +11,17 @@
 
 namespace {
 
-namespace Storage = QmlDesigner::Storage::Synchronization;
+namespace Storage = QmlDesigner::Storage;
+namespace Synchronization = Storage::Synchronization;
 using QmlDesigner::ModuleId;
 using QmlDesigner::SourceContextId;
 using QmlDesigner::SourceId;
 
 MATCHER_P(HasPrototype, prototype, std::string(negation ? "isn't " : "is ") + PrintToString(prototype))
 {
-    const Storage::Type &type = arg;
+    const Synchronization::Type &type = arg;
 
-    return Storage::ImportedTypeName{prototype} == type.prototype;
+    return Synchronization::ImportedTypeName{prototype} == type.prototype;
 }
 
 MATCHER_P3(IsPropertyDeclaration,
@@ -28,12 +29,12 @@ MATCHER_P3(IsPropertyDeclaration,
            typeName,
            traits,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::PropertyDeclaration{name, typeName, traits}))
+               + PrintToString(Synchronization::PropertyDeclaration{name, typeName, traits}))
 {
-    const Storage::PropertyDeclaration &propertyDeclaration = arg;
+    const Synchronization::PropertyDeclaration &propertyDeclaration = arg;
 
     return propertyDeclaration.name == name
-           && Storage::ImportedTypeName{typeName} == propertyDeclaration.typeName
+           && Synchronization::ImportedTypeName{typeName} == propertyDeclaration.typeName
            && propertyDeclaration.traits == traits;
 }
 
@@ -43,12 +44,13 @@ MATCHER_P4(IsAliasPropertyDeclaration,
            traits,
            aliasPropertyName,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::PropertyDeclaration{name, typeName, traits, aliasPropertyName}))
+               + PrintToString(
+                   Synchronization::PropertyDeclaration{name, typeName, traits, aliasPropertyName}))
 {
-    const Storage::PropertyDeclaration &propertyDeclaration = arg;
+    const Synchronization::PropertyDeclaration &propertyDeclaration = arg;
 
     return propertyDeclaration.name == name
-           && Storage::ImportedTypeName{typeName} == propertyDeclaration.typeName
+           && Synchronization::ImportedTypeName{typeName} == propertyDeclaration.typeName
            && propertyDeclaration.traits == traits
            && propertyDeclaration.aliasPropertyName == aliasPropertyName
            && propertyDeclaration.aliasPropertyNameTail.empty();
@@ -61,12 +63,13 @@ MATCHER_P5(IsAliasPropertyDeclaration,
            aliasPropertyName,
            aliasPropertyNameTail,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::PropertyDeclaration{name, typeName, traits, aliasPropertyName}))
+               + PrintToString(
+                   Synchronization::PropertyDeclaration{name, typeName, traits, aliasPropertyName}))
 {
-    const Storage::PropertyDeclaration &propertyDeclaration = arg;
+    const Synchronization::PropertyDeclaration &propertyDeclaration = arg;
 
     return propertyDeclaration.name == name
-           && Storage::ImportedTypeName{typeName} == propertyDeclaration.typeName
+           && Synchronization::ImportedTypeName{typeName} == propertyDeclaration.typeName
            && propertyDeclaration.traits == traits
            && propertyDeclaration.aliasPropertyName == aliasPropertyName
            && propertyDeclaration.aliasPropertyNameTail == aliasPropertyNameTail;
@@ -76,18 +79,19 @@ MATCHER_P2(IsFunctionDeclaration,
            name,
            returnTypeName,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::FunctionDeclaration{name, returnTypeName}))
+               + PrintToString(Synchronization::FunctionDeclaration{name, returnTypeName}))
 {
-    const Storage::FunctionDeclaration &declaration = arg;
+    const Synchronization::FunctionDeclaration &declaration = arg;
 
     return declaration.name == name && declaration.returnTypeName == returnTypeName;
 }
 
 MATCHER_P(IsSignalDeclaration,
           name,
-          std::string(negation ? "isn't " : "is ") + PrintToString(Storage::SignalDeclaration{name}))
+          std::string(negation ? "isn't " : "is ")
+              + PrintToString(Synchronization::SignalDeclaration{name}))
 {
-    const Storage::SignalDeclaration &declaration = arg;
+    const Synchronization::SignalDeclaration &declaration = arg;
 
     return declaration.name == name;
 }
@@ -96,9 +100,9 @@ MATCHER_P2(IsParameter,
            name,
            typeName,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::ParameterDeclaration{name, typeName}))
+               + PrintToString(Synchronization::ParameterDeclaration{name, typeName}))
 {
-    const Storage::ParameterDeclaration &declaration = arg;
+    const Synchronization::ParameterDeclaration &declaration = arg;
 
     return declaration.name == name && declaration.typeName == typeName;
 }
@@ -106,9 +110,9 @@ MATCHER_P2(IsParameter,
 MATCHER_P(IsEnumeration,
           name,
           std::string(negation ? "isn't " : "is ")
-              + PrintToString(Storage::EnumerationDeclaration{name, {}}))
+              + PrintToString(Synchronization::EnumerationDeclaration{name, {}}))
 {
-    const Storage::EnumerationDeclaration &declaration = arg;
+    const Synchronization::EnumerationDeclaration &declaration = arg;
 
     return declaration.name == name;
 }
@@ -116,9 +120,9 @@ MATCHER_P(IsEnumeration,
 MATCHER_P(IsEnumerator,
           name,
           std::string(negation ? "isn't " : "is ")
-              + PrintToString(Storage::EnumeratorDeclaration{name}))
+              + PrintToString(Synchronization::EnumeratorDeclaration{name}))
 {
-    const Storage::EnumeratorDeclaration &declaration = arg;
+    const Synchronization::EnumeratorDeclaration &declaration = arg;
 
     return declaration.name == name && !declaration.hasValue;
 }
@@ -127,9 +131,9 @@ MATCHER_P2(IsEnumerator,
            name,
            value,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::EnumeratorDeclaration{name, value, true}))
+               + PrintToString(Synchronization::EnumeratorDeclaration{name, value, true}))
 {
-    const Storage::EnumeratorDeclaration &declaration = arg;
+    const Synchronization::EnumeratorDeclaration &declaration = arg;
 
     return declaration.name == name && declaration.value == value && declaration.hasValue;
 }
@@ -154,7 +158,7 @@ TEST_F(QmlDocumentParser, prototype)
 {
     auto type = parser.parse("Example{}", imports, qmlFileSourceId, directoryPath);
 
-    ASSERT_THAT(type, HasPrototype(Storage::ImportedType("Example")));
+    ASSERT_THAT(type, HasPrototype(Synchronization::ImportedType("Example")));
 }
 
 TEST_F(QmlDocumentParser, qualified_prototype)
@@ -166,11 +170,9 @@ TEST_F(QmlDocumentParser, qualified_prototype)
     auto type = parser.parse(text, imports, qmlFileSourceId, directoryPath);
 
     ASSERT_THAT(type,
-                HasPrototype(
-                    Storage::QualifiedImportedType("Item",
-                                                   Storage::Import{exampleModuleId,
-                                                                   QmlDesigner::Storage::Version{2, 1},
-                                                                   qmlFileSourceId})));
+                HasPrototype(Synchronization::QualifiedImportedType(
+                    "Item",
+                    Storage::Import{exampleModuleId, Storage::Version{2, 1}, qmlFileSourceId})));
 }
 
 TEST_F(QmlDocumentParser, properties)
@@ -178,10 +180,9 @@ TEST_F(QmlDocumentParser, properties)
     auto type = parser.parse(R"(Example{ property int foo })", imports, qmlFileSourceId, directoryPath);
 
     ASSERT_THAT(type.propertyDeclarations,
-                UnorderedElementsAre(
-                    IsPropertyDeclaration("foo",
-                                          Storage::ImportedType{"int"},
-                                          QmlDesigner::Storage::PropertyDeclarationTraits::None)));
+                UnorderedElementsAre(IsPropertyDeclaration("foo",
+                                                           Synchronization::ImportedType{"int"},
+                                                           Storage::PropertyDeclarationTraits::None)));
 }
 
 TEST_F(QmlDocumentParser, qualified_properties)
@@ -197,11 +198,11 @@ TEST_F(QmlDocumentParser, qualified_properties)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(IsPropertyDeclaration(
                     "foo",
-                    Storage::QualifiedImportedType("Foo",
-                                                   Storage::Import{exampleModuleId,
-                                                                   QmlDesigner::Storage::Version{2, 1},
-                                                                   qmlFileSourceId}),
-                    QmlDesigner::Storage::PropertyDeclarationTraits::None)));
+                    Synchronization::QualifiedImportedType("Foo",
+                                                           Storage::Import{exampleModuleId,
+                                                                           Storage::Version{2, 1},
+                                                                           qmlFileSourceId}),
+                    Storage::PropertyDeclarationTraits::None)));
 }
 
 TEST_F(QmlDocumentParser, enumeration_in_properties)
@@ -215,8 +216,8 @@ TEST_F(QmlDocumentParser, enumeration_in_properties)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(
                     IsPropertyDeclaration("foo",
-                                          Storage::ImportedType("Enumeration.Foo"),
-                                          QmlDesigner::Storage::PropertyDeclarationTraits::None)));
+                                          Synchronization::ImportedType("Enumeration.Foo"),
+                                          Storage::PropertyDeclarationTraits::None)));
 }
 
 TEST_F(QmlDocumentParser, qualified_enumeration_in_properties)
@@ -232,11 +233,11 @@ TEST_F(QmlDocumentParser, qualified_enumeration_in_properties)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(IsPropertyDeclaration(
                     "foo",
-                    Storage::QualifiedImportedType("Enumeration.Foo",
-                                                   Storage::Import{exampleModuleId,
-                                                                   QmlDesigner::Storage::Version{2, 1},
-                                                                   qmlFileSourceId}),
-                    QmlDesigner::Storage::PropertyDeclarationTraits::None)));
+                    Synchronization::QualifiedImportedType("Enumeration.Foo",
+                                                           Storage::Import{exampleModuleId,
+                                                                           Storage::Version{2, 1},
+                                                                           qmlFileSourceId}),
+                    Storage::PropertyDeclarationTraits::None)));
 }
 
 TEST_F(QmlDocumentParser, imports)
@@ -252,13 +253,12 @@ TEST_F(QmlDocumentParser, imports)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(
-        imports,
-        UnorderedElementsAre(
-            Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{fooDirectoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId}));
+    ASSERT_THAT(imports,
+                UnorderedElementsAre(
+                    Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{fooDirectoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qmlModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qtQuickModuleId, Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, imports_with_version)
@@ -274,13 +274,12 @@ TEST_F(QmlDocumentParser, imports_with_version)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(
-        imports,
-        UnorderedElementsAre(
-            Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{fooDirectoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{2, 1}, qmlFileSourceId}));
+    ASSERT_THAT(imports,
+                UnorderedElementsAre(
+                    Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{fooDirectoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qmlModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qtQuickModuleId, Storage::Version{2, 1}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, imports_with_explict_directory)
@@ -296,11 +295,11 @@ TEST_F(QmlDocumentParser, imports_with_explict_directory)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(imports,
-                UnorderedElementsAre(
-                    Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-                    Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId}));
+    ASSERT_THAT(
+        imports,
+        UnorderedElementsAre(Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
+                             Storage::Import{qmlModuleId, Storage::Version{}, qmlFileSourceId},
+                             Storage::Import{qtQuickModuleId, Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, functions)
@@ -312,12 +311,12 @@ TEST_F(QmlDocumentParser, functions)
         directoryPath);
 
     ASSERT_THAT(type.functionDeclarations,
-                UnorderedElementsAre(AllOf(IsFunctionDeclaration("otherFunction", ""),
-                                           Field(&Storage::FunctionDeclaration::parameters, IsEmpty())),
-                                     AllOf(IsFunctionDeclaration("someScript", ""),
-                                           Field(&Storage::FunctionDeclaration::parameters,
-                                                 ElementsAre(IsParameter("x", ""),
-                                                             IsParameter("y", ""))))));
+                UnorderedElementsAre(
+                    AllOf(IsFunctionDeclaration("otherFunction", ""),
+                          Field(&Synchronization::FunctionDeclaration::parameters, IsEmpty())),
+                    AllOf(IsFunctionDeclaration("someScript", ""),
+                          Field(&Synchronization::FunctionDeclaration::parameters,
+                                ElementsAre(IsParameter("x", ""), IsParameter("y", ""))))));
 }
 
 TEST_F(QmlDocumentParser, signals)
@@ -328,12 +327,12 @@ TEST_F(QmlDocumentParser, signals)
                              directoryPath);
 
     ASSERT_THAT(type.signalDeclarations,
-                UnorderedElementsAre(AllOf(IsSignalDeclaration("someSignal"),
-                                           Field(&Storage::SignalDeclaration::parameters,
-                                                 ElementsAre(IsParameter("x", "int"),
-                                                             IsParameter("y", "real")))),
-                                     AllOf(IsSignalDeclaration("signal2"),
-                                           Field(&Storage::SignalDeclaration::parameters, IsEmpty()))));
+                UnorderedElementsAre(
+                    AllOf(IsSignalDeclaration("someSignal"),
+                          Field(&Synchronization::SignalDeclaration::parameters,
+                                ElementsAre(IsParameter("x", "int"), IsParameter("y", "real")))),
+                    AllOf(IsSignalDeclaration("signal2"),
+                          Field(&Synchronization::SignalDeclaration::parameters, IsEmpty()))));
 }
 
 TEST_F(QmlDocumentParser, enumeration)
@@ -347,13 +346,13 @@ TEST_F(QmlDocumentParser, enumeration)
     ASSERT_THAT(type.enumerationDeclarations,
                 UnorderedElementsAre(
                     AllOf(IsEnumeration("Color"),
-                          Field(&Storage::EnumerationDeclaration::enumeratorDeclarations,
+                          Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
                                 ElementsAre(IsEnumerator("red", 0),
                                             IsEnumerator("green", 1),
                                             IsEnumerator("blue", 10),
                                             IsEnumerator("white", 11)))),
                     AllOf(IsEnumeration("State"),
-                          Field(&Storage::EnumerationDeclaration::enumeratorDeclarations,
+                          Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
                                 ElementsAre(IsEnumerator("On", 0), IsEnumerator("Off", 1))))));
 }
 
@@ -376,14 +375,13 @@ TEST_F(QmlDocumentParser, DISABLED_duplicate_imports_are_removed)
                              qmlFileSourceId,
                              directoryPath);
 
-    ASSERT_THAT(
-        imports,
-        UnorderedElementsAre(
-            Storage::Import{directoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{fooDirectoryModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId},
-            Storage::Import{qmlModuleId, QmlDesigner::Storage::Version{1, 0}, qmlFileSourceId},
-            Storage::Import{qtQmlModuleId, QmlDesigner::Storage::Version{6, 0}, qmlFileSourceId},
-            Storage::Import{qtQuickModuleId, QmlDesigner::Storage::Version{}, qmlFileSourceId}));
+    ASSERT_THAT(imports,
+                UnorderedElementsAre(
+                    Storage::Import{directoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{fooDirectoryModuleId, Storage::Version{}, qmlFileSourceId},
+                    Storage::Import{qmlModuleId, Storage::Version{1, 0}, qmlFileSourceId},
+                    Storage::Import{qtQmlModuleId, Storage::Version{6, 0}, qmlFileSourceId},
+                    Storage::Import{qtQuickModuleId, Storage::Version{}, qmlFileSourceId}));
 }
 
 TEST_F(QmlDocumentParser, alias_item_properties)
@@ -399,10 +397,9 @@ TEST_F(QmlDocumentParser, alias_item_properties)
                              directoryPath);
 
     ASSERT_THAT(type.propertyDeclarations,
-                UnorderedElementsAre(
-                    IsPropertyDeclaration("delegate",
-                                          Storage::ImportedType{"Item"},
-                                          QmlDesigner::Storage::PropertyDeclarationTraits::None)));
+                UnorderedElementsAre(IsPropertyDeclaration("delegate",
+                                                           Synchronization::ImportedType{"Item"},
+                                                           Storage::PropertyDeclarationTraits::None)));
 }
 
 TEST_F(QmlDocumentParser, alias_properties)
@@ -420,8 +417,8 @@ TEST_F(QmlDocumentParser, alias_properties)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(
                     IsAliasPropertyDeclaration("text",
-                                               Storage::ImportedType{"Item"},
-                                               QmlDesigner::Storage::PropertyDeclarationTraits::None,
+                                               Synchronization::ImportedType{"Item"},
+                                               Storage::PropertyDeclarationTraits::None,
                                                "text2")));
 }
 
@@ -440,8 +437,8 @@ TEST_F(QmlDocumentParser, indirect_alias_properties)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(
                     IsAliasPropertyDeclaration("textSize",
-                                               Storage::ImportedType{"Item"},
-                                               QmlDesigner::Storage::PropertyDeclarationTraits::None,
+                                               Synchronization::ImportedType{"Item"},
+                                               Storage::PropertyDeclarationTraits::None,
                                                "text",
                                                "size")));
 }
@@ -473,8 +470,8 @@ TEST_F(QmlDocumentParser, list_property)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(
                     IsPropertyDeclaration("foos",
-                                          Storage::ImportedType{"Foo"},
-                                          QmlDesigner::Storage::PropertyDeclarationTraits::IsList)));
+                                          Synchronization::ImportedType{"Foo"},
+                                          Storage::PropertyDeclarationTraits::IsList)));
 }
 
 TEST_F(QmlDocumentParser, alias_on_list_property)
@@ -494,8 +491,8 @@ TEST_F(QmlDocumentParser, alias_on_list_property)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(
                     IsPropertyDeclaration("foos",
-                                          Storage::ImportedType{"Foo"},
-                                          QmlDesigner::Storage::PropertyDeclarationTraits::IsList)));
+                                          Synchronization::ImportedType{"Foo"},
+                                          Storage::PropertyDeclarationTraits::IsList)));
 }
 
 TEST_F(QmlDocumentParser, qualified_list_property)
@@ -512,11 +509,11 @@ TEST_F(QmlDocumentParser, qualified_list_property)
     ASSERT_THAT(type.propertyDeclarations,
                 UnorderedElementsAre(IsPropertyDeclaration(
                     "foos",
-                    Storage::QualifiedImportedType{"Foo",
-                                                   Storage::Import{exampleModuleId,
-                                                                   QmlDesigner::Storage::Version{2, 1},
-                                                                   qmlFileSourceId}},
-                    QmlDesigner::Storage::PropertyDeclarationTraits::IsList)));
+                    Synchronization::QualifiedImportedType{"Foo",
+                                                           Storage::Import{exampleModuleId,
+                                                                           Storage::Version{2, 1},
+                                                                           qmlFileSourceId}},
+                    Storage::PropertyDeclarationTraits::IsList)));
 }
 
 } // namespace

tests/unit/tests/unittests/projectstorage/qmltypesparser-test.cpp

@@ -12,7 +12,8 @@
 
 namespace {
 
-namespace Storage = QmlDesigner::Storage::Synchronization;
+namespace Storage = QmlDesigner::Storage;
+namespace Synchronization = QmlDesigner::Storage::Synchronization;
 using QmlDesigner::ModuleId;
 using QmlDesigner::SourceContextId;
 using QmlDesigner::SourceId;
@@ -31,9 +32,9 @@ MATCHER_P3(IsImport,
 
 MATCHER_P(HasPrototype, prototype, std::string(negation ? "isn't " : "is ") + PrintToString(prototype))
 {
-    const Storage::Type &type = arg;
+    const Synchronization::Type &type = arg;
 
-    return Storage::ImportedTypeName{prototype} == type.prototype;
+    return Synchronization::ImportedTypeName{prototype} == type.prototype;
 }
 
 MATCHER_P5(IsType,
@@ -43,13 +44,13 @@ MATCHER_P5(IsType,
            traits,
            sourceId,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::Type{typeName, prototype, extension, traits, sourceId}))
+               + PrintToString(Synchronization::Type{typeName, prototype, extension, traits, sourceId}))
 {
-    const Storage::Type &type = arg;
+    const Synchronization::Type &type = arg;
 
-    return type.typeName == typeName && type.prototype == Storage::ImportedTypeName{prototype}
-           && type.extension == Storage::ImportedTypeName{extension} && type.traits == traits
-           && type.sourceId == sourceId;
+    return type.typeName == typeName && type.prototype == Synchronization::ImportedTypeName{prototype}
+           && type.extension == Synchronization::ImportedTypeName{extension}
+           && type.traits == traits && type.sourceId == sourceId;
 }
 
 MATCHER_P3(IsPropertyDeclaration,
@@ -57,32 +58,33 @@ MATCHER_P3(IsPropertyDeclaration,
            typeName,
            traits,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::PropertyDeclaration{name, typeName, traits}))
+               + PrintToString(Synchronization::PropertyDeclaration{name, typeName, traits}))
 {
-    const Storage::PropertyDeclaration &propertyDeclaration = arg;
+    const Synchronization::PropertyDeclaration &propertyDeclaration = arg;
 
     return propertyDeclaration.name == name
-           && Storage::ImportedTypeName{typeName} == propertyDeclaration.typeName
+           && Synchronization::ImportedTypeName{typeName} == propertyDeclaration.typeName
            && propertyDeclaration.traits == traits
-           && propertyDeclaration.kind == Storage::PropertyKind::Property;
+           && propertyDeclaration.kind == Synchronization::PropertyKind::Property;
 }
 
 MATCHER_P2(IsFunctionDeclaration,
            name,
            returnTypeName,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::FunctionDeclaration{name, returnTypeName}))
+               + PrintToString(Synchronization::FunctionDeclaration{name, returnTypeName}))
 {
-    const Storage::FunctionDeclaration &declaration = arg;
+    const Synchronization::FunctionDeclaration &declaration = arg;
 
     return declaration.name == name && declaration.returnTypeName == returnTypeName;
 }
 
 MATCHER_P(IsSignalDeclaration,
           name,
-          std::string(negation ? "isn't " : "is ") + PrintToString(Storage::SignalDeclaration{name}))
+          std::string(negation ? "isn't " : "is ")
+              + PrintToString(Synchronization::SignalDeclaration{name}))
 {
-    const Storage::SignalDeclaration &declaration = arg;
+    const Synchronization::SignalDeclaration &declaration = arg;
 
     return declaration.name == name;
 }
@@ -91,9 +93,9 @@ MATCHER_P2(IsParameter,
            name,
            typeName,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::ParameterDeclaration{name, typeName}))
+               + PrintToString(Synchronization::ParameterDeclaration{name, typeName}))
 {
-    const Storage::ParameterDeclaration &declaration = arg;
+    const Synchronization::ParameterDeclaration &declaration = arg;
 
     return declaration.name == name && declaration.typeName == typeName;
 }
@@ -101,9 +103,9 @@ MATCHER_P2(IsParameter,
 MATCHER_P(IsEnumeration,
           name,
           std::string(negation ? "isn't " : "is ")
-              + PrintToString(Storage::EnumerationDeclaration{name, {}}))
+              + PrintToString(Synchronization::EnumerationDeclaration{name, {}}))
 {
-    const Storage::EnumerationDeclaration &declaration = arg;
+    const Synchronization::EnumerationDeclaration &declaration = arg;
 
     return declaration.name == name;
 }
@@ -111,9 +113,9 @@ MATCHER_P(IsEnumeration,
 MATCHER_P(IsEnumerator,
           name,
           std::string(negation ? "isn't " : "is ")
-              + PrintToString(Storage::EnumeratorDeclaration{name}))
+              + PrintToString(Synchronization::EnumeratorDeclaration{name}))
 {
-    const Storage::EnumeratorDeclaration &declaration = arg;
+    const Synchronization::EnumeratorDeclaration &declaration = arg;
 
     return declaration.name == name && !declaration.hasValue;
 }
@@ -122,9 +124,9 @@ MATCHER_P2(IsEnumerator,
            name,
            value,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::EnumeratorDeclaration{name, value, true}))
+               + PrintToString(Synchronization::EnumeratorDeclaration{name, value, true}))
 {
-    const Storage::EnumeratorDeclaration &declaration = arg;
+    const Synchronization::EnumeratorDeclaration &declaration = arg;
 
     return declaration.name == name && declaration.value == value && declaration.hasValue;
 }
@@ -134,9 +136,9 @@ MATCHER_P3(IsExportedType,
            name,
            version,
            std::string(negation ? "isn't " : "is ")
-               + PrintToString(Storage::ExportedType{moduleId, name, version}))
+               + PrintToString(Synchronization::ExportedType{moduleId, name, version}))
 {
-    const Storage::ExportedType &type = arg;
+    const Synchronization::ExportedType &type = arg;
 
     return type.name == name && type.moduleId == moduleId && type.version == version;
 }
@@ -151,13 +153,13 @@ protected:
         storage};
     QmlDesigner::QmlTypesParser parser{storage};
     Storage::Imports imports;
-    Storage::Types types;
+    Synchronization::Types types;
     SourceId qmltypesFileSourceId{sourcePathCache.sourceId("path/to/types.qmltypes")};
     ModuleId qtQmlNativeModuleId = storage.moduleId("QtQml-cppnative");
-    Storage::ProjectData projectData{qmltypesFileSourceId,
-                                     qmltypesFileSourceId,
-                                     qtQmlNativeModuleId,
-                                     Storage::FileType::QmlTypes};
+    Synchronization::ProjectData projectData{qmltypesFileSourceId,
+                                             qmltypesFileSourceId,
+                                             qtQmlNativeModuleId,
+                                             Synchronization::FileType::QmlTypes};
     SourceContextId qmltypesFileSourceContextId{sourcePathCache.sourceContextId(qmltypesFileSourceId)};
     ModuleId directoryModuleId{storage.moduleId("path/to/")};
 };
@@ -200,14 +202,14 @@ TEST_F(QmlTypesParser, types)
 
     ASSERT_THAT(types,
                 UnorderedElementsAre(IsType("QObject",
-                                            Storage::ImportedType{},
-                                            Storage::ImportedType{},
-                                            QmlDesigner::Storage::TypeTraits::Reference,
+                                            Synchronization::ImportedType{},
+                                            Synchronization::ImportedType{},
+                                            Storage::TypeTraits::Reference,
                                             qmltypesFileSourceId),
                                      IsType("QQmlComponent",
-                                            Storage::ImportedType{},
-                                            Storage::ImportedType{},
-                                            QmlDesigner::Storage::TypeTraits::Reference,
+                                            Synchronization::ImportedType{},
+                                            Synchronization::ImportedType{},
+                                            Storage::TypeTraits::Reference,
                                             qmltypesFileSourceId)));
 }
 
@@ -223,14 +225,14 @@ TEST_F(QmlTypesParser, prototype)
 
     ASSERT_THAT(types,
                 UnorderedElementsAre(IsType("QObject",
-                                            Storage::ImportedType{},
-                                            Storage::ImportedType{},
-                                            QmlDesigner::Storage::TypeTraits::Reference,
+                                            Synchronization::ImportedType{},
+                                            Synchronization::ImportedType{},
+                                            Storage::TypeTraits::Reference,
                                             qmltypesFileSourceId),
                                      IsType("QQmlComponent",
-                                            Storage::ImportedType{"QObject"},
-                                            Storage::ImportedType{},
-                                            QmlDesigner::Storage::TypeTraits::Reference,
+                                            Synchronization::ImportedType{"QObject"},
+                                            Synchronization::ImportedType{},
+                                            Storage::TypeTraits::Reference,
                                             qmltypesFileSourceId)));
 }
 
@@ -246,14 +248,14 @@ TEST_F(QmlTypesParser, extension)
 
     ASSERT_THAT(types,
                 UnorderedElementsAre(IsType("QObject",
-                                            Storage::ImportedType{},
-                                            Storage::ImportedType{},
-                                            QmlDesigner::Storage::TypeTraits::Reference,
+                                            Synchronization::ImportedType{},
+                                            Synchronization::ImportedType{},
+                                            Storage::TypeTraits::Reference,
                                             qmltypesFileSourceId),
                                      IsType("QQmlComponent",
-                                            Storage::ImportedType{},
-                                            Storage::ImportedType{"QObject"},
-                                            QmlDesigner::Storage::TypeTraits::Reference,
+                                            Synchronization::ImportedType{},
+                                            Synchronization::ImportedType{"QObject"},
+                                            Storage::TypeTraits::Reference,
                                             qmltypesFileSourceId)));
 }
 
@@ -272,7 +274,7 @@ TEST_F(QmlTypesParser, exported_types)
     ASSERT_THAT(
         types,
         ElementsAre(Field(
-            &Storage::Type::exportedTypes,
+            &Synchronization::Type::exportedTypes,
             UnorderedElementsAre(
                 IsExportedType(qmlModuleId, "QtObject", QmlDesigner::Storage::Version{1, 0}),
                 IsExportedType(qtQmlModuleId, "QtObject", QmlDesigner::Storage::Version{2, 1}),
@@ -292,25 +294,24 @@ TEST_F(QmlTypesParser, properties)
 
     parser.parse(source, imports, types, projectData);
 
-    ASSERT_THAT(
-        types,
-        ElementsAre(Field(
-            &Storage::Type::propertyDeclarations,
-            UnorderedElementsAre(
-                IsPropertyDeclaration("objectName",
-                                      Storage::ImportedType{"string"},
-                                      QmlDesigner::Storage::PropertyDeclarationTraits::None),
-                IsPropertyDeclaration("target",
-                                      Storage::ImportedType{"QObject"},
-                                      QmlDesigner::Storage::PropertyDeclarationTraits::IsPointer),
-                IsPropertyDeclaration("progress",
-                                      Storage::ImportedType{"double"},
-                                      QmlDesigner::Storage::PropertyDeclarationTraits::IsReadOnly),
-                IsPropertyDeclaration("targets",
-                                      Storage::ImportedType{"QQuickItem"},
-                                      QmlDesigner::Storage::PropertyDeclarationTraits::IsReadOnly
-                                          | QmlDesigner::Storage::PropertyDeclarationTraits::IsList
-                                          | QmlDesigner::Storage::PropertyDeclarationTraits::IsPointer)))));
+    ASSERT_THAT(types,
+                ElementsAre(Field(
+                    &Synchronization::Type::propertyDeclarations,
+                    UnorderedElementsAre(
+                        IsPropertyDeclaration("objectName",
+                                              Synchronization::ImportedType{"string"},
+                                              Storage::PropertyDeclarationTraits::None),
+                        IsPropertyDeclaration("target",
+                                              Synchronization::ImportedType{"QObject"},
+                                              Storage::PropertyDeclarationTraits::IsPointer),
+                        IsPropertyDeclaration("progress",
+                                              Synchronization::ImportedType{"double"},
+                                              Storage::PropertyDeclarationTraits::IsReadOnly),
+                        IsPropertyDeclaration("targets",
+                                              Synchronization::ImportedType{"QQuickItem"},
+                                              Storage::PropertyDeclarationTraits::IsReadOnly
+                                                  | Storage::PropertyDeclarationTraits::IsList
+                                                  | Storage::PropertyDeclarationTraits::IsPointer)))));
 }
 
 TEST_F(QmlTypesParser, properties_with_qualified_types)
@@ -327,20 +328,19 @@ TEST_F(QmlTypesParser, properties_with_qualified_types)
 
     parser.parse(source, imports, types, projectData);
 
-    ASSERT_THAT(
-        types,
-        Contains(
-            Field(&Storage::Type::propertyDeclarations,
-                  UnorderedElementsAre(
-                      IsPropertyDeclaration("values",
-                                            Storage::ImportedType{"Qt::Vector"},
-                                            QmlDesigner::Storage::PropertyDeclarationTraits::None),
-                      IsPropertyDeclaration("items",
-                                            Storage::ImportedType{"Qt::List"},
-                                            QmlDesigner::Storage::PropertyDeclarationTraits::None),
-                      IsPropertyDeclaration("values2",
-                                            Storage::ImportedType{"Qt::Vector"},
-                                            QmlDesigner::Storage::PropertyDeclarationTraits::None)))));
+    ASSERT_THAT(types,
+                Contains(
+                    Field(&Synchronization::Type::propertyDeclarations,
+                          UnorderedElementsAre(
+                              IsPropertyDeclaration("values",
+                                                    Synchronization::ImportedType{"Qt::Vector"},
+                                                    Storage::PropertyDeclarationTraits::None),
+                              IsPropertyDeclaration("items",
+                                                    Synchronization::ImportedType{"Qt::List"},
+                                                    Storage::PropertyDeclarationTraits::None),
+                              IsPropertyDeclaration("values2",
+                                                    Synchronization::ImportedType{"Qt::Vector"},
+                                                    Storage::PropertyDeclarationTraits::None)))));
 }
 
 TEST_F(QmlTypesParser, properties_without_type)
@@ -355,11 +355,12 @@ TEST_F(QmlTypesParser, properties_without_type)
     parser.parse(source, imports, types, projectData);
 
     ASSERT_THAT(types,
-                ElementsAre(Field(&Storage::Type::propertyDeclarations,
-                                  UnorderedElementsAre(IsPropertyDeclaration(
-                                      "target",
-                                      Storage::ImportedType{"QObject"},
-                                      QmlDesigner::Storage::PropertyDeclarationTraits::IsPointer)))));
+                ElementsAre(
+                    Field(&Synchronization::Type::propertyDeclarations,
+                          UnorderedElementsAre(
+                              IsPropertyDeclaration("target",
+                                                    Synchronization::ImportedType{"QObject"},
+                                                    Storage::PropertyDeclarationTraits::IsPointer)))));
 }
 
 TEST_F(QmlTypesParser, functions)
@@ -387,21 +388,21 @@ TEST_F(QmlTypesParser, functions)
     parser.parse(source, imports, types, projectData);
 
     ASSERT_THAT(types,
-                ElementsAre(
-                    Field(&Storage::Type::functionDeclarations,
-                          UnorderedElementsAre(
-                              AllOf(IsFunctionDeclaration("advance", ""),
-                                    Field(&Storage::FunctionDeclaration::parameters,
-                                          UnorderedElementsAre(IsParameter("frames", "int"),
-                                                               IsParameter("fps", "double")))),
-                              AllOf(IsFunctionDeclaration("isImageLoading", "bool"),
-                                    Field(&Storage::FunctionDeclaration::parameters,
-                                          UnorderedElementsAre(IsParameter("url", "QUrl")))),
-                              AllOf(IsFunctionDeclaration("getContext", ""),
-                                    Field(&Storage::FunctionDeclaration::parameters,
-                                          UnorderedElementsAre(IsParameter("args", "QQmlV4Function")))),
-                              AllOf(IsFunctionDeclaration("movieUpdate", ""),
-                                    Field(&Storage::FunctionDeclaration::parameters, IsEmpty()))))));
+                ElementsAre(Field(
+                    &Synchronization::Type::functionDeclarations,
+                    UnorderedElementsAre(
+                        AllOf(IsFunctionDeclaration("advance", ""),
+                              Field(&Synchronization::FunctionDeclaration::parameters,
+                                    UnorderedElementsAre(IsParameter("frames", "int"),
+                                                         IsParameter("fps", "double")))),
+                        AllOf(IsFunctionDeclaration("isImageLoading", "bool"),
+                              Field(&Synchronization::FunctionDeclaration::parameters,
+                                    UnorderedElementsAre(IsParameter("url", "QUrl")))),
+                        AllOf(IsFunctionDeclaration("getContext", ""),
+                              Field(&Synchronization::FunctionDeclaration::parameters,
+                                    UnorderedElementsAre(IsParameter("args", "QQmlV4Function")))),
+                        AllOf(IsFunctionDeclaration("movieUpdate", ""),
+                              Field(&Synchronization::FunctionDeclaration::parameters, IsEmpty()))))));
 }
 
 TEST_F(QmlTypesParser, skip_java_script_functions)
@@ -417,7 +418,7 @@ TEST_F(QmlTypesParser, skip_java_script_functions)
 
     parser.parse(source, imports, types, projectData);
 
-    ASSERT_THAT(types, ElementsAre(Field(&Storage::Type::functionDeclarations, IsEmpty())));
+    ASSERT_THAT(types, ElementsAre(Field(&Synchronization::Type::functionDeclarations, IsEmpty())));
 }
 
 TEST_F(QmlTypesParser, functions_with_qualified_types)
@@ -439,15 +440,16 @@ TEST_F(QmlTypesParser, functions_with_qualified_types)
 
     ASSERT_THAT(types,
                 Contains(
-                    Field(&Storage::Type::functionDeclarations,
+                    Field(&Synchronization::Type::functionDeclarations,
                           UnorderedElementsAre(AllOf(
                               IsFunctionDeclaration("values", ""),
-                              Field(&Storage::FunctionDeclaration::parameters,
+                              Field(&Synchronization::FunctionDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("values", "Qt::Vector"),
                                                          IsParameter("items", "Qt::List"),
                                                          IsParameter("values2", "Qt::Vector"))))))));
 }
 
+#undef signals
 TEST_F(QmlTypesParser, signals)
 {
     QString source{R"(import QtQuick.tooling 1.2
@@ -472,17 +474,17 @@ TEST_F(QmlTypesParser, signals)
     parser.parse(source, imports, types, projectData);
 
     ASSERT_THAT(types,
-                ElementsAre(Field(&Storage::Type::signalDeclarations,
+                ElementsAre(Field(&Synchronization::Type::signalDeclarations,
                                   UnorderedElementsAre(
                                       AllOf(IsSignalDeclaration("advance"),
-                                            Field(&Storage::SignalDeclaration::parameters,
+                                            Field(&Synchronization::SignalDeclaration::parameters,
                                                   UnorderedElementsAre(IsParameter("frames", "int"),
                                                                        IsParameter("fps", "double")))),
                                       AllOf(IsSignalDeclaration("isImageLoading"),
-                                            Field(&Storage::SignalDeclaration::parameters,
+                                            Field(&Synchronization::SignalDeclaration::parameters,
                                                   UnorderedElementsAre(IsParameter("url", "QUrl")))),
                                       AllOf(IsSignalDeclaration("getContext"),
-                                            Field(&Storage::SignalDeclaration::parameters,
+                                            Field(&Synchronization::SignalDeclaration::parameters,
                                                   UnorderedElementsAre(
                                                       IsParameter("args", "QQmlV4Function"))))))));
 }
@@ -506,10 +508,10 @@ TEST_F(QmlTypesParser, signals_with_qualified_types)
 
     ASSERT_THAT(types,
                 Contains(
-                    Field(&Storage::Type::signalDeclarations,
+                    Field(&Synchronization::Type::signalDeclarations,
                           UnorderedElementsAre(AllOf(
                               IsSignalDeclaration("values"),
-                              Field(&Storage::SignalDeclaration::parameters,
+                              Field(&Synchronization::SignalDeclaration::parameters,
                                     UnorderedElementsAre(IsParameter("values", "Qt::Vector"),
                                                          IsParameter("items", "Qt::List"),
                                                          IsParameter("values2", "Qt::Vector"))))))));
@@ -538,19 +540,19 @@ TEST_F(QmlTypesParser, enumerations)
     parser.parse(source, imports, types, projectData);
 
     ASSERT_THAT(types,
-                Contains(
-                    Field(&Storage::Type::enumerationDeclarations,
-                          UnorderedElementsAre(
-                              AllOf(IsEnumeration("NamedColorSpace"),
-                                    Field(&Storage::EnumerationDeclaration::enumeratorDeclarations,
-                                          UnorderedElementsAre(IsEnumerator("Unknown"),
-                                                               IsEnumerator("SRgb"),
-                                                               IsEnumerator("AdobeRgb"),
-                                                               IsEnumerator("DisplayP3")))),
-                              AllOf(IsEnumeration("VerticalLayoutDirection"),
-                                    Field(&Storage::EnumerationDeclaration::enumeratorDeclarations,
-                                          UnorderedElementsAre(IsEnumerator("TopToBottom"),
-                                                               IsEnumerator("BottomToTop"))))))));
+                Contains(Field(
+                    &Synchronization::Type::enumerationDeclarations,
+                    UnorderedElementsAre(
+                        AllOf(IsEnumeration("NamedColorSpace"),
+                              Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
+                                    UnorderedElementsAre(IsEnumerator("Unknown"),
+                                                         IsEnumerator("SRgb"),
+                                                         IsEnumerator("AdobeRgb"),
+                                                         IsEnumerator("DisplayP3")))),
+                        AllOf(IsEnumeration("VerticalLayoutDirection"),
+                              Field(&Synchronization::EnumerationDeclaration::enumeratorDeclarations,
+                                    UnorderedElementsAre(IsEnumerator("TopToBottom"),
+                                                         IsEnumerator("BottomToTop"))))))));
 }
 
 TEST_F(QmlTypesParser, enumeration_is_exported_as_type)
@@ -580,20 +582,20 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type)
         types,
         UnorderedElementsAre(
             AllOf(IsType("QObject::NamedColorSpace",
-                         Storage::ImportedType{},
-                         Storage::ImportedType{},
-                         QmlDesigner::Storage::TypeTraits::Value | QmlDesigner::Storage::TypeTraits::IsEnum,
+                         Synchronization::ImportedType{},
+                         Synchronization::ImportedType{},
+                         Storage::TypeTraits::Value | Storage::TypeTraits::IsEnum,
                          qmltypesFileSourceId),
-                  Field(&Storage::Type::exportedTypes,
+                  Field(&Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                             "QObject::NamedColorSpace",
                                                             QmlDesigner::Storage::Version{})))),
             AllOf(IsType("QObject::VerticalLayoutDirection",
-                         Storage::ImportedType{},
-                         Storage::ImportedType{},
-                         QmlDesigner::Storage::TypeTraits::Value | QmlDesigner::Storage::TypeTraits::IsEnum,
+                         Synchronization::ImportedType{},
+                         Synchronization::ImportedType{},
+                         Storage::TypeTraits::Value | Storage::TypeTraits::IsEnum,
                          qmltypesFileSourceId),
-                  Field(&Storage::Type::exportedTypes,
+                  Field(&Synchronization::Type::exportedTypes,
                         UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                             "QObject::VerticalLayoutDirection",
                                                             QmlDesigner::Storage::Version{})))),
@@ -623,12 +625,11 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type_with_alias)
     ASSERT_THAT(types,
                 UnorderedElementsAre(
                     AllOf(IsType("QObject::NamedColorSpaces",
-                                 Storage::ImportedType{},
-                                 Storage::ImportedType{},
-                                 QmlDesigner::Storage::TypeTraits::Value
-                                     | QmlDesigner::Storage::TypeTraits::IsEnum,
+                                 Synchronization::ImportedType{},
+                                 Synchronization::ImportedType{},
+                                 Storage::TypeTraits::Value | Storage::TypeTraits::IsEnum,
                                  qmltypesFileSourceId),
-                          Field(&Storage::Type::exportedTypes,
+                          Field(&Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpace",
                                                                     QmlDesigner::Storage::Version{}),
@@ -670,12 +671,11 @@ TEST_F(QmlTypesParser, enumeration_is_exported_as_type_with_alias_too)
     ASSERT_THAT(types,
                 UnorderedElementsAre(
                     AllOf(IsType("QObject::NamedColorSpaces",
-                                 Storage::ImportedType{},
-                                 Storage::ImportedType{},
-                                 QmlDesigner::Storage::TypeTraits::Value
-                                     | QmlDesigner::Storage::TypeTraits::IsEnum,
+                                 Synchronization::ImportedType{},
+                                 Synchronization::ImportedType{},
+                                 Storage::TypeTraits::Value | Storage::TypeTraits::IsEnum,
                                  qmltypesFileSourceId),
-                          Field(&Storage::Type::exportedTypes,
+                          Field(&Synchronization::Type::exportedTypes,
                                 UnorderedElementsAre(IsExportedType(qtQmlNativeModuleId,
                                                                     "QObject::NamedColorSpace",
                                                                     QmlDesigner::Storage::Version{}),
@@ -705,10 +705,10 @@ TEST_F(QmlTypesParser, enumeration_is_referenced_by_qualified_name)
     parser.parse(source, imports, types, projectData);
 
     ASSERT_THAT(types,
-                Contains(Field(&Storage::Type::propertyDeclarations,
+                Contains(Field(&Synchronization::Type::propertyDeclarations,
                                ElementsAre(IsPropertyDeclaration(
                                    "colorSpace",
-                                   Storage::ImportedType{"QObject::NamedColorSpace"},
+                                   Synchronization::ImportedType{"QObject::NamedColorSpace"},
                                    QmlDesigner::Storage::PropertyDeclarationTraits::None)))));
 }
 
@@ -733,10 +733,10 @@ TEST_F(QmlTypesParser, alias_enumeration_is_referenced_by_qualified_name)
     parser.parse(source, imports, types, projectData);
 
     ASSERT_THAT(types,
-                Contains(Field(&Storage::Type::propertyDeclarations,
+                Contains(Field(&Synchronization::Type::propertyDeclarations,
                                ElementsAre(IsPropertyDeclaration(
                                    "colorSpace",
-                                   Storage::ImportedType{"QObject::NamedColorSpaces"},
+                                   Synchronization::ImportedType{"QObject::NamedColorSpaces"},
                                    QmlDesigner::Storage::PropertyDeclarationTraits::None)))));
 }
 

tests/unit/tests/utils/googletest.h

@@ -7,20 +7,20 @@
 #  pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
 #endif
 
-#include <gmock/gmock-matchers.h>
-#include <gmock/gmock.h>
-#include <gtest/gtest-printers.h>
-#include <gtest/gtest-typed-test.h>
-#include <gtest/gtest.h>
-
-#include "../utils/google-using-declarations.h"
-
 #include "conditionally-disabled-tests.h"
 
 #include "../printers/gtest-creator-printing.h"
 #include "../printers/gtest-qt-printing.h"
 #include "../printers/gtest-std-printing.h"
 
+#include "../utils/google-using-declarations.h"
+
 #include "../matchers/unittest-matchers.h"
 
 #include "unittest-utility-functions.h"
+
+#include <gmock/gmock-matchers.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest-printers.h>
+#include <gtest/gtest-typed-test.h>
+#include <gtest/gtest.h>