CMake: Use FolderNode::addNestedNodes for unique_ptr in server-mode

Remove FolderNode::addNestedNodes that take raw pointers now that the
last user is gone.

Change-Id: If2ca3864934d9239ac136e65c0b7dbcea7caf220
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>

src/plugins/cmakeprojectmanager/servermodereader.cpp

@@ -258,9 +258,10 @@ CMakeConfig ServerModeReader::takeParsedConfiguration()
 }
 
 static void addCMakeVFolder(FolderNode *base, const Utils::FileName &basePath, int priority,
-                     const QString &displayName, const QList<FileNode *> &files)
+                            const QString &displayName,
+                            std::vector<std::unique_ptr<FileNode>> &&files)
 {
-    if (files.isEmpty())
+    if (files.size() == 0)
         return;
     FolderNode *folder = base;
     if (!displayName.isEmpty()) {
@@ -269,28 +270,28 @@ static void addCMakeVFolder(FolderNode *base, const Utils::FileName &basePath, i
         folder = newFolder.get();
         base->addNode(std::move(newFolder));
     }
-    folder->addNestedNodes(files);
+    folder->addNestedNodes(std::move(files));
     for (FolderNode *fn : folder->folderNodes())
         fn->compress();
 }
 
-static QList<FileNode *> removeKnownNodes(const QSet<Utils::FileName> &knownFiles, const QList<FileNode *> &files)
+static std::vector<std::unique_ptr<FileNode>> &&
+removeKnownNodes(const QSet<Utils::FileName> &knownFiles,
+                 std::vector<std::unique_ptr<FileNode>> &&files)
 {
-    return Utils::filtered(files, [&knownFiles](const FileNode *n) {
+    std::remove_if(std::begin(files), std::end(files),
-        if (knownFiles.contains(n->filePath())) {
+                   [&knownFiles](const std::unique_ptr<FileNode> &n) {
-            delete n;
+        return knownFiles.contains(n->filePath());
-            return false;
-        }
-        return true;
     });
+    return std::move(files);
 }
 
 static void addCMakeInputs(FolderNode *root,
                            const Utils::FileName &sourceDir,
                            const Utils::FileName &buildDir,
-                           QList<FileNode *> &sourceInputs,
+                           std::vector<std::unique_ptr<FileNode>> &&sourceInputs,
-                           QList<FileNode *> &buildInputs,
+                           std::vector<std::unique_ptr<FileNode>> &&buildInputs,
-                           QList<FileNode *> &rootInputs)
+                           std::vector<std::unique_ptr<FileNode>> &&rootInputs)
 {
     std::unique_ptr<ProjectNode> cmakeVFolder = std::make_unique<CMakeInputsNode>(root->filePath());
 
@@ -300,13 +301,13 @@ static void addCMakeInputs(FolderNode *root,
             knownFiles.insert(n->filePath());
     });
 
-    addCMakeVFolder(cmakeVFolder.get(), sourceDir, 1000, QString(), removeKnownNodes(knownFiles, sourceInputs));
+    addCMakeVFolder(cmakeVFolder.get(), sourceDir, 1000, QString(), removeKnownNodes(knownFiles, std::move(sourceInputs)));
     addCMakeVFolder(cmakeVFolder.get(), buildDir, 100,
                     QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Build Directory>"),
-                    removeKnownNodes(knownFiles, buildInputs));
+                    removeKnownNodes(knownFiles, std::move(buildInputs)));
     addCMakeVFolder(cmakeVFolder.get(), Utils::FileName(), 10,
                     QCoreApplication::translate("CMakeProjectManager::Internal::ServerModeReader", "<Other Locations>"),
-                    removeKnownNodes(knownFiles, rootInputs));
+                    removeKnownNodes(knownFiles, std::move(rootInputs)));
 
     root->addNode(std::move(cmakeVFolder));
 }
@@ -315,21 +316,21 @@ void ServerModeReader::generateProjectTree(CMakeProjectNode *root,
                                            const QList<const FileNode *> &allFiles)
 {
     // Split up cmake inputs into useful chunks:
-    QList<FileNode *> cmakeFilesSource;
+    std::vector<std::unique_ptr<FileNode>> cmakeFilesSource;
-    QList<FileNode *> cmakeFilesBuild;
+    std::vector<std::unique_ptr<FileNode>> cmakeFilesBuild;
-    QList<FileNode *> cmakeFilesOther;
+    std::vector<std::unique_ptr<FileNode>> cmakeFilesOther;
-    QList<FileNode *> cmakeLists;
+    std::vector<std::unique_ptr<FileNode>> cmakeLists;
 
-    foreach (FileNode *fn, m_cmakeInputsFileNodes) {
+    for (std::unique_ptr<FileNode> &fn : m_cmakeInputsFileNodes) {
         const FileName path = fn->filePath();
         if (path.fileName().compare("CMakeLists.txt", HostOsInfo::fileNameCaseSensitivity()) == 0)
-            cmakeLists.append(fn);
+            cmakeLists.emplace_back(std::move(fn));
         else if (path.isChildOf(m_parameters.workDirectory))
-            cmakeFilesBuild.append(fn);
+            cmakeFilesBuild.emplace_back(std::move(fn));
         else if (path.isChildOf(m_parameters.sourceDirectory))
-            cmakeFilesSource.append(fn);
+            cmakeFilesSource.emplace_back(std::move(fn));
         else
-            cmakeFilesOther.append(fn);
+            cmakeFilesOther.emplace_back(std::move(fn));
     }
     m_cmakeInputsFileNodes.clear(); // Clean out, they are not going to be used anymore!
 
@@ -339,15 +340,17 @@ void ServerModeReader::generateProjectTree(CMakeProjectNode *root,
     if (topLevel)
         root->setDisplayName(topLevel->name);
 
-    QHash<Utils::FileName, ProjectNode *> cmakeListsNodes = addCMakeLists(root, cmakeLists);
+    QHash<Utils::FileName, ProjectNode *> cmakeListsNodes
+            = addCMakeLists(root, std::move(cmakeLists));
     QList<FileNode *> knownHeaders;
     addProjects(cmakeListsNodes, m_projects, knownHeaders);
 
     addHeaderNodes(root, knownHeaders, allFiles);
 
-    if (!cmakeFilesSource.isEmpty() || !cmakeFilesBuild.isEmpty() || !cmakeFilesOther.isEmpty())
+    if (cmakeFilesSource.size() > 0 || cmakeFilesBuild.size() > 0 || cmakeFilesOther.size() > 0)
         addCMakeInputs(root, m_parameters.sourceDirectory, m_parameters.workDirectory,
-                       cmakeFilesSource, cmakeFilesBuild, cmakeFilesOther);
+                       std::move(cmakeFilesSource), std::move(cmakeFilesBuild),
+                       std::move(cmakeFilesOther));
 }
 
 void ServerModeReader::updateCodeModel(CppTools::RawProjectParts &rpps)
@@ -651,7 +654,8 @@ void ServerModeReader::extractCMakeInputsData(const QVariantMap &data)
             if (oldCount < m_cmakeFiles.count() && (!isCMake || sfn.toString().endsWith("/CMakeLists.txt"))) {
                 // Always include CMakeLists.txt files, even when cmake things these are part of its
                 // stuff. This unbreaks cmake binaries running from their own build directory.
-                m_cmakeInputsFileNodes.append(new FileNode(sfn, FileType::Project, isTemporary));
+                m_cmakeInputsFileNodes.emplace_back(
+                            std::make_unique<FileNode>(sfn, FileType::Project, isTemporary));
             }
         }
     }
@@ -720,14 +724,17 @@ void ServerModeReader::fixTarget(ServerModeReader::Target *target) const
 }
 
 QHash<Utils::FileName, ProjectNode *>
-ServerModeReader::addCMakeLists(CMakeProjectNode *root, const QList<FileNode *> &cmakeLists)
+ServerModeReader::addCMakeLists(CMakeProjectNode *root,
+                                std::vector<std::unique_ptr<FileNode>> &&cmakeLists)
 {
     QHash<Utils::FileName, ProjectNode *> cmakeListsNodes;
     cmakeListsNodes.insert(root->filePath(), root);
 
     const QSet<Utils::FileName> cmakeDirs
-            = Utils::transform<QSet>(cmakeLists, [](const Node *n) { return n->filePath().parentDir(); });
+            = Utils::transform<QSet>(cmakeLists, [](const std::unique_ptr<FileNode> &n) {
-    root->addNestedNodes(cmakeLists, Utils::FileName(),
+        return n->filePath().parentDir();
+    });
+    root->addNestedNodes(std::move(cmakeLists), Utils::FileName(),
                          [&cmakeDirs, &cmakeListsNodes](const Utils::FileName &fp)
                          -> std::unique_ptr<ProjectExplorer::FolderNode> {
         if (cmakeDirs.contains(fp)) {
@@ -840,7 +847,7 @@ void ServerModeReader::addFileGroups(ProjectNode *targetRoot,
                                      const QList<ServerModeReader::FileGroup *> &fileGroups,
                                      QList<FileNode *> &knownHeaderNodes)
 {
-    QList<FileNode *> toList;
+    std::vector<std::unique_ptr<FileNode>> toList;
     QSet<Utils::FileName> alreadyListed;
     // Files already added by other configurations:
     targetRoot->forEachGenericNode([&alreadyListed](const Node *n) {
@@ -853,33 +860,35 @@ void ServerModeReader::addFileGroups(ProjectNode *targetRoot,
             alreadyListed.insert(fn);
             return count != alreadyListed.count();
         });
-        const QList<FileNode *> newFileNodes
+        std::vector<std::unique_ptr<FileNode>> newFileNodes
-                = Utils::transform(newSources, [f, &knownHeaderNodes](const Utils::FileName &fn) {
+                = Utils::transform<std::vector>(newSources,
-            auto node = new FileNode(fn, Node::fileTypeForFileName(fn), f->isGenerated);
+                                                [f, &knownHeaderNodes](const Utils::FileName &fn) {
+            auto node
+                    = std::make_unique<FileNode>(fn, Node::fileTypeForFileName(fn), f->isGenerated);
             if (node->fileType() == FileType::Header)
-                knownHeaderNodes.append(node);
+                knownHeaderNodes.append(node.get());
             return node;
         });
-        toList.append(newFileNodes);
+        std::move(std::begin(newFileNodes), std::end(newFileNodes), std::back_inserter(toList));
     }
 
     // Split up files in groups (based on location):
     const bool inSourceBuild = (m_parameters.workDirectory == m_parameters.sourceDirectory);
-    QList<FileNode *> sourceFileNodes;
+    std::vector<std::unique_ptr<FileNode>> sourceFileNodes;
-    QList<FileNode *> buildFileNodes;
+    std::vector<std::unique_ptr<FileNode>> buildFileNodes;
-    QList<FileNode *> otherFileNodes;
+    std::vector<std::unique_ptr<FileNode>> otherFileNodes;
-    foreach (FileNode *fn, toList) {
+    for (std::unique_ptr<FileNode> &fn : toList) {
         if (fn->filePath().isChildOf(m_parameters.workDirectory) && !inSourceBuild)
-            buildFileNodes.append(fn);
+            buildFileNodes.emplace_back(std::move(fn));
         else if (fn->filePath().isChildOf(m_parameters.sourceDirectory))
-            sourceFileNodes.append(fn);
+            sourceFileNodes.emplace_back(std::move(fn));
         else
-            otherFileNodes.append(fn);
+            otherFileNodes.emplace_back(std::move(fn));
     }
 
-    addCMakeVFolder(targetRoot, sourceDirectory, 1000,  QString(), sourceFileNodes);
+    addCMakeVFolder(targetRoot, sourceDirectory, 1000,  QString(), std::move(sourceFileNodes));
-    addCMakeVFolder(targetRoot, buildDirectory, 100, tr("<Build Directory>"), buildFileNodes);
+    addCMakeVFolder(targetRoot, buildDirectory, 100, tr("<Build Directory>"), std::move(buildFileNodes));
-    addCMakeVFolder(targetRoot, Utils::FileName(), 10, tr("<Other Locations>"), otherFileNodes);
+    addCMakeVFolder(targetRoot, Utils::FileName(), 10, tr("<Other Locations>"), std::move(otherFileNodes));
 }
 
 void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *> knownHeaders,
@@ -888,8 +897,10 @@ void ServerModeReader::addHeaderNodes(ProjectNode *root, const QList<FileNode *>
     if (root->isEmpty())
         return;
 
-    static QIcon headerNodeIcon = Core::FileIconProvider::directoryIcon(ProjectExplorer::Constants::FILEOVERLAY_H);
+    static QIcon headerNodeIcon
-    auto headerNode = std::make_unique<VirtualFolderNode>(root->filePath(), Node::DefaultPriority - 5);
+            = Core::FileIconProvider::directoryIcon(ProjectExplorer::Constants::FILEOVERLAY_H);
+    auto headerNode
+            = std::make_unique<VirtualFolderNode>(root->filePath(), Node::DefaultPriority - 5);
     headerNode->setDisplayName(tr("<Headers>"));
     headerNode->setIcon(headerNodeIcon);
 

src/plugins/cmakeprojectmanager/servermodereader.h

@@ -144,7 +144,7 @@ private:
     void fixTarget(Target *target) const;
 
     QHash<Utils::FileName, ProjectExplorer::ProjectNode *>
-    addCMakeLists(CMakeProjectNode *root, const QList<ProjectExplorer::FileNode *> &cmakeLists);
+    addCMakeLists(CMakeProjectNode *root, std::vector<std::unique_ptr<ProjectExplorer::FileNode> > &&cmakeLists);
     void addProjects(const QHash<Utils::FileName, ProjectExplorer::ProjectNode *> &cmakeListsNodes,
                      const QList<Project *> &projects,
                      QList<ProjectExplorer::FileNode *> &knownHeaderNodes);
@@ -169,7 +169,7 @@ private:
     CMakeConfig m_cmakeConfiguration;
 
     QSet<Utils::FileName> m_cmakeFiles;
-    QList<ProjectExplorer::FileNode *> m_cmakeInputsFileNodes;
+    std::vector<std::unique_ptr<ProjectExplorer::FileNode>> m_cmakeInputsFileNodes;
 
     QList<Project *> m_projects;
     QList<Target *> m_targets;

src/plugins/projectexplorer/projectnodes.cpp

@@ -557,13 +557,6 @@ void FolderNode::addNestedNode(std::unique_ptr<FileNode> &&fileNode,
     folder->addNode(std::move(fileNode));
 }
 
-void FolderNode::addNestedNodes(const QList<FileNode *> &files, const Utils::FileName &overrideBaseDir,
-                                const FolderNodeFactory &factory)
-{
-    for (FileNode *fileNode : files)
-        addNestedNode(std::unique_ptr<FileNode>(fileNode), overrideBaseDir, factory);
-}
-
 void FolderNode::addNestedNodes(std::vector<std::unique_ptr<FileNode> > &&files,
                                 const Utils::FileName &overrideBaseDir,
                                 const FolderNode::FolderNodeFactory &factory)

src/plugins/projectexplorer/projectnodes.h

@@ -223,10 +223,6 @@ public:
     FileNode *fileNode(const Utils::FileName &file) const;
     QList<FolderNode *> folderNodes() const;
     using FolderNodeFactory = std::function<std::unique_ptr<FolderNode>(const Utils::FileName &)>;
-    void addNestedNodes(const QList<FileNode *> &files,
-                        const Utils::FileName &overrideBaseDir = Utils::FileName(),
-                        const FolderNodeFactory &factory
-                        = [](const Utils::FileName &fn) {return std::make_unique<FolderNode>(fn); });
     void addNestedNodes(std::vector<std::unique_ptr<FileNode>> &&files,
                         const Utils::FileName &overrideBaseDir = Utils::FileName(),
                         const FolderNodeFactory &factory