QmlProject: Absolute files paths are ignored

This patch fixes issues with adding files to the project by
providing the absolute paths in the .qmlproject file.

- If a directory is given without an explicit file list,
then that directory wil be searched recursively.
- If explicit file list given without a directory, then each
file will be added to the project separately.
- If both provided, then each file wil be prefixed with given
directory, and added project separately.

Task-number: QDS-10636
Change-Id: Ia13964ce2b3f6364d1def1aa71e20ec29f6f3542
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>

src/plugins/qmlprojectmanager/buildsystem/projectitem/converters.cpp

@@ -7,25 +7,6 @@
 
 namespace QmlProjectManager::Converters {
 
-using PropsPair = QPair<QString, QStringList>;
-struct FileProps
-{
-    const PropsPair image{"image",
-                          QStringList{"*.jpeg", "*.jpg", "*.png", "*.svg", "*.hdr", ".ktx"}};
-    const PropsPair qml{"qml", QStringList{"*.qml"}};
-    const PropsPair qmlDir{"qmldir", QStringList{"qmldir"}};
-    const PropsPair javaScr{"javaScript", QStringList{"*.js", "*.ts"}};
-    const PropsPair video{"video", QStringList{"*.mp4"}};
-    const PropsPair sound{"sound", QStringList{"*.mp3", "*.wav"}};
-    const PropsPair font{"font", QStringList{"*.ttf", "*.otf"}};
-    const PropsPair config{"config", QStringList{"*.conf"}};
-    const PropsPair styling{"styling", QStringList{"*.css"}};
-    const PropsPair mesh{"meshes", QStringList{"*.mesh"}};
-    const PropsPair
-        shader{"shader",
-               QStringList{"*.glsl", "*.glslv", "*.glslf", "*.vsh", "*.fsh", "*.vert", "*.frag"}};
-};
-
 QString jsonToQmlProject(const QJsonObject &rootObject)
 {
     QString qmlProjectString;
@@ -37,7 +18,7 @@ QString jsonToQmlProject(const QJsonObject &rootObject)
     QJsonObject versionConfig = rootObject["versions"].toObject();
     QJsonObject environmentConfig = rootObject["environment"].toObject();
     QJsonObject deploymentConfig = rootObject["deployment"].toObject();
-    QJsonObject filesConfig = rootObject["fileGroups"].toObject();
+    QJsonArray filesConfig = rootObject["fileGroups"].toArray();
 
     int indentationLevel = 0;
 
@@ -82,42 +63,22 @@ QString jsonToQmlProject(const QJsonObject &rootObject)
         ts << QString(" ").repeated(indentationLevel * 4) << "}" << Qt::endl;
     };
 
-    auto appendDirectories =
+    auto appendFileGroup =
-        [&startObject, &endObject, &appendString, &filesConfig](const QString &jsonKey,
+        [&startObject, &endObject, &appendString, &appendArray](const QJsonObject &fileGroup,
                                                                 const QString &qmlKey) {
-            QJsonValue dirsObj = filesConfig[jsonKey].toObject()["directories"];
+            startObject(qmlKey);
-            QStringList dirs = dirsObj.toVariant().toStringList();
+            appendString("directory", fileGroup["directory"].toString());
-            foreach (const QString &directory, dirs) {
+            appendString("filter", fileGroup["filters"].toVariant().toStringList().join(";"));
-                startObject(qmlKey);
+            appendArray("files", fileGroup["files"].toVariant().toStringList());
-                appendString("directory", directory);
+            endObject();
-                endObject();
-            }
         };
 
-    auto appendFiles = [&startObject,
+    auto appendQmlFileGroup =
-                        &endObject,
+        [&startObject, &endObject, &appendString](const QJsonObject &fileGroup) {
-                        &appendString,
+            startObject("QmlFiles");
-                        &appendArray,
+            appendString("directory", fileGroup["directory"].toString());
-                        &filesConfig](const QString &jsonKey, const QString &qmlKey) {
-        QJsonValue dirsObj = filesConfig[jsonKey].toObject()["directories"];
-        QJsonValue filesObj = filesConfig[jsonKey].toObject()["files"];
-        QJsonValue filtersObj = filesConfig[jsonKey].toObject()["filters"];
-
-        foreach (const QString &directory, dirsObj.toVariant().toStringList()) {
-            startObject(qmlKey);
-            appendString("directory", directory);
-            appendString("filters", filtersObj.toVariant().toStringList().join(";"));
-
-            if (!filesObj.toArray().isEmpty()) {
-                QStringList fileList;
-                foreach (const QJsonValue &file, filesObj.toArray()) {
-                    fileList.append(file.toObject()["name"].toString());
-                }
-                appendArray("files", fileList);
-            }
             endObject();
-        }
+        };
-    };
 
     // start creating the file content
     appendComment("prop: json-converted");
@@ -127,54 +88,46 @@ QString jsonToQmlProject(const QJsonObject &rootObject)
     {
         startObject("Project");
 
-        { // append non-object props
+        // append non-object props
-            appendString("mainFile", runConfig["mainFile"].toString());
+        appendString("mainFile", runConfig["mainFile"].toString());
-            appendString("mainUiFile", runConfig["mainUiFile"].toString());
+        appendString("mainUiFile", runConfig["mainUiFile"].toString());
-            appendString("targetDirectory", deploymentConfig["targetDirectory"].toString());
+        appendString("targetDirectory", deploymentConfig["targetDirectory"].toString());
-            appendBool("widgetApp", runConfig["widgetApp"].toBool());
+        appendBool("widgetApp", runConfig["widgetApp"].toBool());
-            appendArray("importPaths", rootObject["importPaths"].toVariant().toStringList());
+        appendArray("importPaths", rootObject["importPaths"].toVariant().toStringList());
-            appendBreak();
+        appendBreak();
-            appendString("qdsVersion", versionConfig["designStudio"].toString());
+        appendString("qdsVersion", versionConfig["designStudio"].toString());
-            appendString("quickVersion", versionConfig["qtQuick"].toString());
+        appendString("quickVersion", versionConfig["qtQuick"].toString());
-            appendBool("qt6Project", versionConfig["qt"].toString() == "6");
+        appendBool("qt6Project", versionConfig["qt"].toString() == "6");
-            appendBool("qtForMCUs", !(rootObject["mcuConfig"].toObject().isEmpty()));
+        appendBool("qtForMCUs", !(rootObject["mcuConfig"].toObject().isEmpty()));
-            appendBreak();
+        appendBreak();
-            appendBool("multilanguageSupport", languageConfig["multiLanguageSupport"].toBool());
+        appendBool("multilanguageSupport", languageConfig["multiLanguageSupport"].toBool());
-            appendString("primaryLanguage", languageConfig["primaryLanguage"].toString());
+        appendString("primaryLanguage", languageConfig["primaryLanguage"].toString());
-            appendArray("supportedLanguages",
+        appendArray("supportedLanguages",
-                        languageConfig["supportedLanguages"].toVariant().toStringList());
+                    languageConfig["supportedLanguages"].toVariant().toStringList());
-        }
 
-        { // append Environment object
+        // append Environment object
-            startObject("Environment");
+        startObject("Environment");
-            foreach (const QString &key, environmentConfig.keys()) {
+        foreach (const QString &key, environmentConfig.keys()) {
-                appendItem(key, environmentConfig[key].toString(), true);
+            appendItem(key, environmentConfig[key].toString(), true);
-            }
+        }
+        endObject();
+
+        // append ShaderTool object
+        if (!shaderConfig["args"].toVariant().toStringList().isEmpty()) {
+            startObject("ShaderTool");
+            appendString("args",
+                         shaderConfig["args"].toVariant().toStringList().join(" ").replace("\"",
+                                                                                           "\\\""));
+            appendArray("files", shaderConfig["files"].toVariant().toStringList());
             endObject();
         }
 
-        { // append ShaderTool object
+        // append files objects
-            if (!shaderConfig["args"].toVariant().toStringList().isEmpty()) {
+        for (const QJsonValue &fileGroup : filesConfig) {
-                startObject("ShaderTool");
+            if (fileGroup["filters"].toArray().contains("*.qml"))
-                appendString("args",
+                appendQmlFileGroup(fileGroup.toObject());
-                             shaderConfig["args"].toVariant().toStringList().join(" ").replace(
+            else
-                                 "\"", "\\\""));
+                appendFileGroup(fileGroup.toObject(), "Files");
-                appendArray("files", shaderConfig["files"].toVariant().toStringList());
-                endObject();
-            }
-        }
-
-        { // append files objects
-            appendDirectories("qml", "QmlFiles");
-            appendDirectories("javaScript", "JavaScriptFiles");
-            appendDirectories("image", "ImageFiles");
-            appendFiles("config", "Files");
-            appendFiles("font", "Files");
-            appendFiles("meshes", "Files");
-            appendFiles("qmldir", "Files");
-            appendFiles("shader", "Files");
-            appendFiles("sound", "Files");
-            appendFiles("video", "Files");
         }
 
         endObject(); // Closing 'Project'
@@ -210,7 +163,7 @@ QJsonObject qmlProjectTojson(const Utils::FilePath &projectFile)
     auto toCamelCase = [](const QString &s) { return QString(s).replace(0, 1, s[0].toLower()); };
 
     QJsonObject rootObject; // root object
-    QJsonObject fileGroupsObject;
+    QJsonArray fileGroupsObject;
     QJsonObject languageObject;
     QJsonObject versionObject;
     QJsonObject runConfigObject;
@@ -270,82 +223,51 @@ QJsonObject qmlProjectTojson(const Utils::FilePath &projectFile)
     // convert the the object props
     for (const QmlJS::SimpleReaderNode::Ptr &childNode : rootNode->children()) {
         if (childNode->name().contains("files", Qt::CaseInsensitive)) {
-            PropsPair propsPair;
-            FileProps fileProps;
             const QString childNodeName = childNode->name().toLower().remove("qds.");
-            const QmlJS::SimpleReaderNode::Property childNodeFilter = childNode->property("filter");
+            QJsonArray childNodeFiles = childNode->property("files").value.toJsonArray();
-            const QmlJS::SimpleReaderNode::Property childNodeDirectory = childNode->property(
+            QString childNodeDirectory = childNode->property("directory").value.toString();
-                "directory");
+            QStringList filters = childNode->property("filter").value.toString().split(";");
-            const QmlJS::SimpleReaderNode::Property childNodeFiles = childNode->property("files");
+            filters.removeAll("");
-            const QString childNodeFilterValue = childNodeFilter.value.toString();
+            QJsonArray childNodeFilters = QJsonArray::fromStringList(filters);
 
-            if (childNodeName == "qmlfiles" || childNodeFilterValue.contains("*.qml")) {
+            // files have priority over filters
-                propsPair = fileProps.qml;
+            // if explicit files are given, then filters will be ignored
-            } else if (childNodeName == "javascriptfiles") {
+            // and all files are prefixed such as "directory/<filename>".
-                propsPair = fileProps.javaScr;
+            // if directory is empty, then the files are prefixed with the project directory
-            } else if (childNodeName == "imagefiles") {
+            if (childNodeFiles.empty()) {
-                propsPair = fileProps.image;
+                auto inserter = [&childNodeFilters](const QStringList &filterSource) {
-            } else {
+                    std::for_each(filterSource.begin(),
-                if (childNodeFilter.isValid()) {
+                                  filterSource.end(),
-                    if (childNodeFilterValue.contains(".conf"))
+                                  [&childNodeFilters](const auto &value) {
-                        propsPair = fileProps.config;
+                                      childNodeFilters << value;
-                    else if (childNodeFilterValue.contains(".ttf"))
+                                  });
-                        propsPair = fileProps.font;
+                };
-                    else if (childNodeFilterValue.contains("qmldir"))
+
-                        propsPair = fileProps.qmlDir;
+                // Those 3 file groups are the special ones
-                    else if (childNodeFilterValue.contains(".wav"))
+                // that have a default set of filters. After the first
-                        propsPair = fileProps.sound;
+                // conversion (QmlProject -> JSON) they are converted to
-                    else if (childNodeFilterValue.contains(".mp4"))
+                // the generic file group format ('Files' or 'QDS.Files')
-                        propsPair = fileProps.video;
+                if (childNodeName == "qmlfiles") {
-                    else if (childNodeFilterValue.contains(".mesh"))
+                    inserter({QStringLiteral("*.qml")});
-                        propsPair = fileProps.mesh;
+                } else if (childNodeName == "javascriptfiles") {
-                    else if (childNodeFilterValue.contains(".glsl"))
+                    inserter({QStringLiteral("*.js"), QStringLiteral("*.ts")});
-                        propsPair = fileProps.shader;
+                } else if (childNodeName == "imagefiles") {
-                    else if (childNodeFilterValue.contains(".css"))
+                    inserter({QStringLiteral("*.jpeg"),
-                        propsPair = fileProps.styling;
+                              QStringLiteral("*.jpg"),
+                              QStringLiteral("*.png"),
+                              QStringLiteral("*.svg"),
+                              QStringLiteral("*.hdr"),
+                              QStringLiteral(".ktx")});
                 }
             }
 
-            // get all objects we'll work on
+            // create the file group object
-            QJsonObject targetObject = fileGroupsObject[propsPair.first].toObject();
+            QJsonObject targetObject;
-            QJsonArray directories = targetObject["directories"].toArray();
+            targetObject.insert("directory", childNodeDirectory);
-            QJsonArray filters = targetObject["filters"].toArray();
+            targetObject.insert("filters", childNodeFilters);
-            QJsonArray files = targetObject["files"].toArray();
+            targetObject.insert("files", childNodeFiles);
 
-            // populate & update filters
+            fileGroupsObject.append(targetObject);
-            if (filters.isEmpty()) {
-                filters = QJsonArray::fromStringList(
-                    propsPair.second); // populate the filters with the predefined ones
-            }
-
-            if (childNodeFilter.isValid()) { // append filters from qmlproject (merge)
-                const QStringList filtersFromProjectFile = childNodeFilterValue.split(";");
-                for (const QString &filter : filtersFromProjectFile) {
-                    if (!filters.contains(QJsonValue(filter))) {
-                        filters.append(QJsonValue(filter));
-                    }
-                }
-            }
-
-            // populate & update directories
-            if (childNodeDirectory.isValid()) {
-                directories.append(childNodeDirectory.value.toJsonValue());
-            }
-            if (directories.isEmpty())
-                directories.append(".");
-
-            // populate & update files
-            if (childNodeFiles.isValid()) {
-                foreach (const QJsonValue &file, childNodeFiles.value.toJsonArray()) {
-                    files.append(QJsonObject{{"name", file.toString()}});
-                }
-            }
-
-            // put everything back into the root object
-            targetObject.insert("directories", directories);
-            targetObject.insert("filters", filters);
-            targetObject.insert("files", files);
-            fileGroupsObject.insert(propsPair.first, targetObject);
         } else if (childNode->name().contains("shadertool", Qt::CaseInsensitive)) {
             QStringList quotedArgs
                 = childNode->property("args").value.toString().split('\"', Qt::SkipEmptyParts);

src/plugins/qmlprojectmanager/buildsystem/projectitem/qmlprojectitem.cpp

@@ -65,20 +65,16 @@ bool QmlProjectItem::initProjectObject()
 void QmlProjectItem::setupFileFilters()
 {
     auto setupFileFilterItem = [this](const QJsonObject &fileGroup) {
-        for (const QString &directory : fileGroup["directories"].toVariant().toStringList()) {
+        // first we need to add all directories as a 'resource' path for the project and set them as
+        // recursive.
+        // if there're any files with the explicit absolute paths, we need to add them afterwards.
+        for (const QString &directory : fileGroup["directory"].toVariant().toStringList()) {
             std::unique_ptr<FileFilterItem> fileFilterItem{new FileFilterItem};
-
-            QStringList filesArr;
-            for (const QJsonValue &file : fileGroup["files"].toArray()) {
-                filesArr.append(file["name"].toString());
-            }
-
             fileFilterItem->setDirectory(directory);
             fileFilterItem->setFilters(fileGroup["filters"].toVariant().toStringList());
-            fileFilterItem->setRecursive(fileGroup["recursive"].toBool(true));
+            fileFilterItem->setRecursive(true);
-            fileFilterItem->setPathsProperty(fileGroup["directories"].toVariant().toStringList());
-            fileFilterItem->setPathsProperty(filesArr);
             fileFilterItem->setDefaultDirectory(m_projectFile.parentDir().toString());
+
 #ifndef TESTS_ENABLED_QMLPROJECTITEM
             connect(fileFilterItem.get(),
                     &FileFilterItem::filesChanged,
@@ -87,11 +83,38 @@ void QmlProjectItem::setupFileFilters()
 #endif
             m_content.push_back(std::move(fileFilterItem));
         };
+
+        // here we begin to add files with the explicit absolute paths
+        QJsonArray files = fileGroup["files"].toArray();
+        if (files.isEmpty())
+            return;
+
+        QStringList filesArr;
+        std::transform(files.begin(),
+                       files.end(),
+                       std::back_inserter(filesArr),
+                       [](const QJsonValue &value) { return value.toString(); });
+
+        const QString directory = fileGroup["directory"].toString() == ""
+                                      ? m_projectFile.parentDir().toString()
+                                      : fileGroup["directory"].toString();
+        Utils::FilePath groupDir = Utils::FilePath::fromString(directory);
+        std::unique_ptr<FileFilterItem> fileFilterItem{new FileFilterItem};
+        fileFilterItem->setRecursive(false);
+        fileFilterItem->setPathsProperty(filesArr);
+        fileFilterItem->setDefaultDirectory(m_projectFile.parentDir().toString());
+        fileFilterItem->setDirectory(groupDir.toString());
+#ifndef TESTS_ENABLED_QMLPROJECTITEM
+        connect(fileFilterItem.get(),
+                &FileFilterItem::filesChanged,
+                this,
+                &QmlProjectItem::qmlFilesChanged);
+#endif
+        m_content.push_back(std::move(fileFilterItem));
     };
 
-    QJsonObject fileGroups = m_project["fileGroups"].toObject();
+    for (const QJsonValue &fileGroup : m_project["fileGroups"].toArray()) {
-    for (const QString &groupName : fileGroups.keys()) {
+        setupFileFilterItem(fileGroup.toObject());
-        setupFileFilterItem(fileGroups[groupName].toObject());
     }
 }
 

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-1/testfile.jsontoqml

@@ -40,59 +40,79 @@ Project {
         directory: "imports"
     }
 
-    QmlFiles {
+    Files {
-        directory: "asset_imports"
-    }
-
-    JavaScriptFiles {
         directory: "content"
-    }
+        filter: "*.js;*.ts"
-
+        files: [  ]
-    JavaScriptFiles {
-        directory: "imports"
-    }
-
-    ImageFiles {
-        directory: "content"
-    }
-
-    ImageFiles {
-        directory: "asset_imports"
     }
 
     Files {
-        directory: "."
+        directory: "imports"
-        filters: "*.conf"
+        filter: "*.js;*.ts"
+        files: [  ]
+    }
+
+    Files {
+        directory: "content"
+        filter: "*.jpeg;*.jpg;*.png;*.svg;*.hdr;.ktx"
+        files: [  ]
+    }
+
+    Files {
+        directory: "asset_imports"
+        filter: "*.jpeg;*.jpg;*.png;*.svg;*.hdr;.ktx"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: ""
         files: [ "qtquickcontrols2.conf" ]
     }
 
+    Files {
+        directory: ""
+        filter: "*.conf"
+        files: [  ]
+    }
+
     Files {
         directory: "."
-        filters: "*.ttf;*.otf;*.ctf"
+        filter: "qmldir"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.ttf;*.otf;*.ctf"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.wav;*.mp3"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.mp4"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.glsl;*.glslv;*.glslf;*.vsh;*.fsh;*.vert;*.frag;*.trag"
+        files: [  ]
     }
 
     Files {
         directory: "asset_imports"
-        filters: "*.mesh"
+        filter: "*.mesh"
+        files: [  ]
     }
 
-    Files {
+    QmlFiles {
-        directory: "."
+        directory: "asset_imports"
-        filters: "qmldir"
-    }
-
-    Files {
-        directory: "."
-        filters: "*.glsl;*.glslv;*.glslf;*.vsh;*.fsh;*.vert;*.frag;*.trag"
-    }
-
-    Files {
-        directory: "."
-        filters: "*.mp3;*.wav"
-    }
-
-    Files {
-        directory: "."
-        filters: "*.mp4"
     }
 }

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-1/testfile.qmlproject

@@ -30,10 +30,13 @@ Project {
     }
 
     Files {
-        filter: "*.conf"
         files: ["qtquickcontrols2.conf"]
     }
 
+    Files {
+        filter: "*.conf"
+    }
+
     Files {
         filter: "qmldir"
         directory: "."

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-1/testfile.qmltojson

@@ -9,37 +9,43 @@
         "QT_LOGGING_RULES": "qt.qml.connections=false",
         "QT_QUICK_CONTROLS_CONF": "qtquickcontrols2.conf"
     },
-    "fileGroups": {
+    "fileGroups": [
-        "config": {
+        {
-            "directories": [
+            "directory": "content",
-                "."
-            ],
-            "files": [
-                {
-                    "name": "qtquickcontrols2.conf"
-                }
-            ],
-            "filters": [
-                "*.conf"
-            ]
-        },
-        "font": {
-            "directories": [
-                "."
-            ],
             "files": [
             ],
             "filters": [
-                "*.ttf",
+                "*.qml"
-                "*.otf",
-                "*.ctf"
             ]
         },
-        "image": {
+        {
-            "directories": [
+            "directory": "imports",
-                "content",
+            "files": [
-                "asset_imports"
             ],
+            "filters": [
+                "*.qml"
+            ]
+        },
+        {
+            "directory": "content",
+            "files": [
+            ],
+            "filters": [
+                "*.js",
+                "*.ts"
+            ]
+        },
+        {
+            "directory": "imports",
+            "files": [
+            ],
+            "filters": [
+                "*.js",
+                "*.ts"
+            ]
+        },
+        {
+            "directory": "content",
             "files": [
             ],
             "filters": [
@@ -51,54 +57,72 @@
                 ".ktx"
             ]
         },
-        "javaScript": {
+        {
-            "directories": [
+            "directory": "asset_imports",
-                "content",
-                "imports"
-            ],
             "files": [
             ],
             "filters": [
-                "*.js",
+                "*.jpeg",
-                "*.ts"
+                "*.jpg",
+                "*.png",
+                "*.svg",
+                "*.hdr",
+                ".ktx"
             ]
         },
-        "meshes": {
+        {
-            "directories": [
+            "directory": "",
-                "asset_imports"
+            "files": [
+                "qtquickcontrols2.conf"
             ],
+            "filters": [
+            ]
+        },
+        {
+            "directory": "",
             "files": [
             ],
             "filters": [
-                "*.mesh"
+                "*.conf"
             ]
         },
-        "qml": {
+        {
-            "directories": [
+            "directory": ".",
-                "content",
-                "imports",
-                "asset_imports"
-            ],
-            "files": [
-            ],
-            "filters": [
-                "*.qml"
-            ]
-        },
-        "qmldir": {
-            "directories": [
-                "."
-            ],
             "files": [
             ],
             "filters": [
                 "qmldir"
             ]
         },
-        "shader": {
+        {
-            "directories": [
+            "directory": "",
-                "."
+            "files": [
             ],
+            "filters": [
+                "*.ttf",
+                "*.otf",
+                "*.ctf"
+            ]
+        },
+        {
+            "directory": "",
+            "files": [
+            ],
+            "filters": [
+                "*.wav",
+                "*.mp3"
+            ]
+        },
+        {
+            "directory": "",
+            "files": [
+            ],
+            "filters": [
+                "*.mp4"
+            ]
+        },
+        {
+            "directory": "",
             "files": [
             ],
             "filters": [
@@ -112,28 +136,23 @@
                 "*.trag"
             ]
         },
-        "sound": {
+        {
-            "directories": [
+            "directory": "asset_imports",
-                "."
-            ],
             "files": [
             ],
             "filters": [
-                "*.mp3",
+                "*.mesh"
-                "*.wav"
             ]
         },
-        "video": {
+        {
-            "directories": [
+            "directory": "asset_imports",
-                "."
-            ],
             "files": [
             ],
             "filters": [
-                "*.mp4"
+                "*.qml"
             ]
         }
-    },
+    ],
     "fileVersion": 1,
     "importPaths": [
         "imports",

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-2/testfile.jsontoqml

@@ -28,22 +28,33 @@ Project {
         directory: "."
     }
 
-    JavaScriptFiles {
+    Files {
-        directory: "."
-    }
-
-    ImageFiles {
         directory: "."
+        filter: "*.js;*.ts"
+        files: [  ]
     }
 
     Files {
         directory: "."
-        filters: "*.conf"
+        filter: "*.jpeg;*.jpg;*.png;*.svg;*.hdr;.ktx"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: ""
         files: [ "qtquickcontrols2.conf" ]
     }
 
+    Files {
+        directory: ""
+        filter: "*.conf"
+        files: [  ]
+    }
+
     Files {
         directory: "."
-        filters: "qmldir"
+        filter: "qmldir"
+        files: [  ]
     }
 }

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-2/testfile.qmlproject

@@ -19,10 +19,13 @@ Project {
     }
 
     Files {
-        filter: "*.conf"
         files: ["qtquickcontrols2.conf"]
     }
 
+    Files {
+        filter: "*.conf"
+    }
+
     Files {
         filter: "qmldir"
         directory: "."

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-2/testfile.qmltojson

@@ -6,24 +6,26 @@
         "QT_AUTO_SCREEN_SCALE_FACTOR": "1",
         "QT_QUICK_CONTROLS_CONF": "qtquickcontrols2.conf"
     },
-    "fileGroups": {
+    "fileGroups": [
-        "config": {
+        {
-            "directories": [
+            "directory": ".",
-                "."
-            ],
             "files": [
-                {
-                    "name": "qtquickcontrols2.conf"
-                }
             ],
             "filters": [
-                "*.conf"
+                "*.qml"
             ]
         },
-        "image": {
+        {
-            "directories": [
+            "directory": ".",
-                "."
+            "files": [
             ],
+            "filters": [
+                "*.js",
+                "*.ts"
+            ]
+        },
+        {
+            "directory": ".",
             "files": [
             ],
             "filters": [
@@ -35,38 +37,31 @@
                 ".ktx"
             ]
         },
-        "javaScript": {
+        {
-            "directories": [
+            "directory": "",
-                "."
+            "files": [
+                "qtquickcontrols2.conf"
             ],
+            "filters": [
+            ]
+        },
+        {
+            "directory": "",
             "files": [
             ],
             "filters": [
-                "*.js",
+                "*.conf"
-                "*.ts"
             ]
         },
-        "qml": {
+        {
-            "directories": [
+            "directory": ".",
-                "."
-            ],
-            "files": [
-            ],
-            "filters": [
-                "*.qml"
-            ]
-        },
-        "qmldir": {
-            "directories": [
-                "."
-            ],
             "files": [
             ],
             "filters": [
                 "qmldir"
             ]
         }
-    },
+    ],
     "fileVersion": 1,
     "importPaths": [
         "imports"

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-3/testfile.jsontoqml

@@ -40,59 +40,79 @@ Project {
         directory: "imports"
     }
 
-    QmlFiles {
+    Files {
-        directory: "asset_imports"
-    }
-
-    JavaScriptFiles {
         directory: "content"
-    }
+        filter: "*.js;*.ts"
-
+        files: [  ]
-    JavaScriptFiles {
-        directory: "imports"
-    }
-
-    ImageFiles {
-        directory: "content"
-    }
-
-    ImageFiles {
-        directory: "asset_imports"
     }
 
     Files {
-        directory: "."
+        directory: "imports"
-        filters: "*.conf"
+        filter: "*.js;*.ts"
+        files: [  ]
+    }
+
+    Files {
+        directory: "content"
+        filter: "*.jpeg;*.jpg;*.png;*.svg;*.hdr;.ktx"
+        files: [  ]
+    }
+
+    Files {
+        directory: "asset_imports"
+        filter: "*.jpeg;*.jpg;*.png;*.svg;*.hdr;.ktx"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: ""
         files: [ "qtquickcontrols2.conf" ]
     }
 
+    Files {
+        directory: ""
+        filter: "*.conf"
+        files: [  ]
+    }
+
     Files {
         directory: "."
-        filters: "*.ttf;*.otf;*.ctf"
+        filter: "qmldir"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.ttf;*.otf;*.ctf"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.wav;*.mp3"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.mp4"
+        files: [  ]
+    }
+
+    Files {
+        directory: ""
+        filter: "*.glsl;*.glslv;*.glslf;*.vsh;*.fsh;*.vert;*.frag;*.trag"
+        files: [  ]
     }
 
     Files {
         directory: "asset_imports"
-        filters: "*.mesh"
+        filter: "*.mesh"
+        files: [  ]
     }
 
-    Files {
+    QmlFiles {
-        directory: "."
+        directory: "asset_imports"
-        filters: "qmldir"
-    }
-
-    Files {
-        directory: "."
-        filters: "*.glsl;*.glslv;*.glslf;*.vsh;*.fsh;*.vert;*.frag;*.trag"
-    }
-
-    Files {
-        directory: "."
-        filters: "*.mp3;*.wav"
-    }
-
-    Files {
-        directory: "."
-        filters: "*.mp4"
     }
 }

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-3/testfile.qmlproject

@@ -30,10 +30,13 @@ Project {
     }
 
     QDS.Files {
-        filter: "*.conf"
         files: ["qtquickcontrols2.conf"]
     }
 
+    QDS.Files {
+        filter: "*.conf"
+    }
+
     QDS.Files {
         filter: "qmldir"
         directory: "."

tests/unit/tests/unittests/qmlprojectmanager/data/converter/test-set-3/testfile.qmltojson

@@ -9,37 +9,43 @@
         "QT_LOGGING_RULES": "qt.qml.connections=false",
         "QT_QUICK_CONTROLS_CONF": "qtquickcontrols2.conf"
     },
-    "fileGroups": {
+    "fileGroups": [
-        "config": {
+        {
-            "directories": [
+            "directory": "content",
-                "."
-            ],
-            "files": [
-                {
-                    "name": "qtquickcontrols2.conf"
-                }
-            ],
-            "filters": [
-                "*.conf"
-            ]
-        },
-        "font": {
-            "directories": [
-                "."
-            ],
             "files": [
             ],
             "filters": [
-                "*.ttf",
+                "*.qml"
-                "*.otf",
-                "*.ctf"
             ]
         },
-        "image": {
+        {
-            "directories": [
+            "directory": "imports",
-                "content",
+            "files": [
-                "asset_imports"
             ],
+            "filters": [
+                "*.qml"
+            ]
+        },
+        {
+            "directory": "content",
+            "files": [
+            ],
+            "filters": [
+                "*.js",
+                "*.ts"
+            ]
+        },
+        {
+            "directory": "imports",
+            "files": [
+            ],
+            "filters": [
+                "*.js",
+                "*.ts"
+            ]
+        },
+        {
+            "directory": "content",
             "files": [
             ],
             "filters": [
@@ -51,54 +57,72 @@
                 ".ktx"
             ]
         },
-        "javaScript": {
+        {
-            "directories": [
+            "directory": "asset_imports",
-                "content",
-                "imports"
-            ],
             "files": [
             ],
             "filters": [
-                "*.js",
+                "*.jpeg",
-                "*.ts"
+                "*.jpg",
+                "*.png",
+                "*.svg",
+                "*.hdr",
+                ".ktx"
             ]
         },
-        "meshes": {
+        {
-            "directories": [
+            "directory": "",
-                "asset_imports"
+            "files": [
+                "qtquickcontrols2.conf"
             ],
+            "filters": [
+            ]
+        },
+        {
+            "directory": "",
             "files": [
             ],
             "filters": [
-                "*.mesh"
+                "*.conf"
             ]
         },
-        "qml": {
+        {
-            "directories": [
+            "directory": ".",
-                "content",
-                "imports",
-                "asset_imports"
-            ],
-            "files": [
-            ],
-            "filters": [
-                "*.qml"
-            ]
-        },
-        "qmldir": {
-            "directories": [
-                "."
-            ],
             "files": [
             ],
             "filters": [
                 "qmldir"
             ]
         },
-        "shader": {
+        {
-            "directories": [
+            "directory": "",
-                "."
+            "files": [
             ],
+            "filters": [
+                "*.ttf",
+                "*.otf",
+                "*.ctf"
+            ]
+        },
+        {
+            "directory": "",
+            "files": [
+            ],
+            "filters": [
+                "*.wav",
+                "*.mp3"
+            ]
+        },
+        {
+            "directory": "",
+            "files": [
+            ],
+            "filters": [
+                "*.mp4"
+            ]
+        },
+        {
+            "directory": "",
             "files": [
             ],
             "filters": [
@@ -112,28 +136,23 @@
                 "*.trag"
             ]
         },
-        "sound": {
+        {
-            "directories": [
+            "directory": "asset_imports",
-                "."
-            ],
             "files": [
             ],
             "filters": [
-                "*.mp3",
+                "*.mesh"
-                "*.wav"
             ]
         },
-        "video": {
+        {
-            "directories": [
+            "directory": "asset_imports",
-                "."
-            ],
             "files": [
             ],
             "filters": [
-                "*.mp4"
+                "*.qml"
             ]
         }
-    },
+    ],
     "fileVersion": 1,
     "importPaths": [
         "imports",

tests/unit/tests/unittests/qmlprojectmanager/projectitem-test.cpp

@@ -1,6 +1,8 @@
 // Copyright (C) 2023 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
+// clazy:excludeall=non-pod-global-static
+
 #include "../utils/google-using-declarations.h"
 #include "../utils/googletest.h" // IWYU pragma: keep
 
@@ -44,15 +46,14 @@ protected:
     }
 
 protected:
-    static inline std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemEmpty;
+    inline static std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemEmpty;
-    static inline std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemWithQdsPrefix;
+    inline static std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemWithQdsPrefix;
-    static inline std::unique_ptr<const QmlProjectManager::QmlProjectItem>
+    inline static std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemWithoutQdsPrefix;
-        projectItemWithoutQdsPrefix;
     std::unique_ptr<QmlProjectManager::QmlProjectItem> projectItemSetters = std::make_unique<
         QmlProjectManager::QmlProjectItem>(Utils::FilePath::fromString(
                                                localTestDataDir + "/getter-setter/empty.qmlproject"),
                                            true);
-    static inline std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemFileFilters;
+    inline static std::unique_ptr<const QmlProjectManager::QmlProjectItem> projectItemFileFilters;
 };
 
 auto createAbsoluteFilePaths(const QStringList &fileList)