ProjectExplorer: Use unique_ptr for Project::setRootProjectNode

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

src/plugins/autotoolsprojectmanager/autotoolsproject.cpp

@@ -206,12 +206,12 @@ void AutotoolsProject::makefileParsingFinished()
         m_watchedFiles.append(absConfigureAc);
     }
 
-    auto newRoot = new AutotoolsProjectNode(projectDirectory());
+    auto newRoot = std::make_unique<AutotoolsProjectNode>(projectDirectory());
     for (const QString &f : m_files) {
         const Utils::FileName path = Utils::FileName::fromString(f);
         newRoot->addNestedNode(new FileNode(path, FileNode::fileTypeForFileName(path), false));
     }
-    setRootProjectNode(newRoot);
+    setRootProjectNode(std::move(newRoot));
 
     updateCppCodeModel();
 

src/plugins/cmakeprojectmanager/cmakeproject.cpp

@@ -272,7 +272,7 @@ void CMakeProject::updateProjectData(CMakeBuildConfiguration *bc)
     auto newRoot = generateProjectTree(m_allFiles);
     if (newRoot) {
         setDisplayName(newRoot->displayName());
-        setRootProjectNode(newRoot);
+        setRootProjectNode(std::move(newRoot));
     }
 
     updateApplicationAndDeploymentTargets();
@@ -348,14 +348,15 @@ void CMakeProject::updateQmlJSCodeModel()
     modelManager->updateProjectInfo(projectInfo, this);
 }
 
-CMakeProjectNode *CMakeProject::generateProjectTree(const QList<const FileNode *> &allFiles) const
+std::unique_ptr<CMakeProjectNode>
+CMakeProject::generateProjectTree(const QList<const FileNode *> &allFiles) const
 {
     if (m_buildDirManager.isParsing())
         return nullptr;
 
     auto root = std::make_unique<CMakeProjectNode>(projectDirectory());
     m_buildDirManager.generateProjectTree(root.get(), allFiles);
-    return root ? root.release() : nullptr;
+    return root;
 }
 
 bool CMakeProject::knowsAllBuildExecutables() const

src/plugins/cmakeprojectmanager/cmakeproject.h

@@ -99,7 +99,7 @@ private:
     void updateProjectData(Internal::CMakeBuildConfiguration *bc);
     void updateQmlJSCodeModel();
 
-    Internal::CMakeProjectNode *
+    std::unique_ptr<Internal::CMakeProjectNode>
     generateProjectTree(const QList<const ProjectExplorer::FileNode*> &allFiles) const;
 
     void createGeneratedCodeModelSupport();

src/plugins/genericprojectmanager/genericproject.cpp

@@ -339,7 +339,7 @@ void GenericProject::refresh(RefreshOptions options)
     parseProject(options);
 
     if (options & Files) {
-        auto newRoot = new GenericProjectNode(this);
+        auto newRoot = std::make_unique<GenericProjectNode>(this);
 
         for (const QString &f : m_files) {
             FileType fileType = FileType::Source; // ### FIXME
@@ -358,7 +358,7 @@ void GenericProject::refresh(RefreshOptions options)
                                              FileType::Project,
                                              /* generated = */ false));
 
-        setRootProjectNode(newRoot);
+        setRootProjectNode(std::move(newRoot));
     }
 
     refreshCppCodeModel();

src/plugins/nim/project/nimproject.cpp

@@ -147,10 +147,10 @@ void NimProject::updateProject()
     if (oldFiles == m_files)
         return;
 
-    auto newRoot = new NimProjectNode(*this, projectDirectory());
+    auto newRoot = std::make_unique<NimProjectNode>(*this, projectDirectory());
     newRoot->setDisplayName(displayName());
     newRoot->addNestedNodes(fileNodes);
-    setRootProjectNode(newRoot);
+    setRootProjectNode(std::move(newRoot));
     emitParsingFinished(true);
 }
 

src/plugins/projectexplorer/project.cpp

@@ -491,28 +491,26 @@ void Project::setId(Core::Id id)
     d->m_id = id;
 }
 
-void Project::setRootProjectNode(ProjectNode *root)
+void Project::setRootProjectNode(std::unique_ptr<ProjectNode> &&root)
 {
-    if (d->m_rootProjectNode.get() == root)
+    QTC_ASSERT(d->m_rootProjectNode.get() != root.get(), return);
-        return;
 
     if (root && root->isEmpty()) {
         // Something went wrong with parsing: At least the project file needs to be
         // shown so that the user can fix the breakage.
         // Do not leak root and use default project tree in this case.
-        delete root;
+        root.reset();
-        root = nullptr;
     }
 
     if (root) {
-        ProjectTree::applyTreeManager(root);
+        ProjectTree::applyTreeManager(root.get());
         root->setParentFolderNode(d->m_containerNode.get());
     }
 
     std::unique_ptr<ProjectNode> oldNode = std::move(d->m_rootProjectNode);
 
-    d->m_rootProjectNode.reset(root);
+    d->m_rootProjectNode = std::move(root);
-    if (oldNode || root)
+    if (oldNode || d->m_rootProjectNode)
         handleSubTreeChanged(d->m_containerNode.get());
 }
 
@@ -1049,13 +1047,13 @@ void ProjectExplorerPlugin::testProject_projectTree()
     QCOMPARE(fileSpy.count(), 0);
     QVERIFY(!project.rootProjectNode());
 
-    project.setRootProjectNode(new TestProjectNode(project.projectDirectory())); // will delete the fileNode...
+    project.setRootProjectNode(std::make_unique<TestProjectNode>(project.projectDirectory()));
     QCOMPARE(fileSpy.count(), 0);
     QVERIFY(!project.rootProjectNode());
 
     std::unique_ptr<ProjectNode> root = createFileTree(&project);
     ProjectNode *rootNode = root.get();
-    project.setRootProjectNode(root.release());
+    project.setRootProjectNode(std::move(root));
     QCOMPARE(fileSpy.count(), 1);
     QCOMPARE(project.rootProjectNode(), rootNode);
 
@@ -1077,10 +1075,6 @@ void ProjectExplorerPlugin::testProject_projectTree()
     QVERIFY(sourceFiles.contains(TEST_PROJECT_PATH));
     QVERIFY(sourceFiles.contains(TEST_PROJECT_CPP_FILE));
 
-    project.setRootProjectNode(rootNode);
-    QCOMPARE(fileSpy.count(), 1);
-    QCOMPARE(project.rootProjectNode(), rootNode);
-
     project.setRootProjectNode(nullptr);
     QCOMPARE(fileSpy.count(), 2);
     QVERIFY(!project.rootProjectNode());

src/plugins/projectexplorer/project.h

@@ -232,7 +232,7 @@ protected:
     void setPreferredKitPredicate(const Kit::Predicate &predicate);
 
     void setId(Core::Id id);
-    void setRootProjectNode(ProjectNode *root); // takes ownership!
+    void setRootProjectNode(std::unique_ptr<ProjectNode> &&root); // takes ownership!
     void setProjectLanguages(Core::Context language);
     void addProjectLanguage(Core::Id id);
     void removeProjectLanguage(Core::Id id);

src/plugins/pythoneditor/pythoneditorplugin.cpp

@@ -457,7 +457,7 @@ void PythonProject::refresh(Target *target)
 
     QDir baseDir(projectDirectory().toString());
     BuildTargetInfoList appTargets;
-    auto newRoot = new PythonProjectNode(this);
+    auto newRoot = std::make_unique<PythonProjectNode>(this);
     for (const QString &f : m_files) {
         const QString displayName = baseDir.relativeFilePath(f);
         FileType fileType = f.endsWith(".pyqtc") ? FileType::Project : FileType::Source;
@@ -470,7 +470,7 @@ void PythonProject::refresh(Target *target)
             appTargets.list.append(bti);
         }
     }
-    setRootProjectNode(newRoot);
+    setRootProjectNode(std::move(newRoot));
 
     if (!target)
         target = activeTarget();

src/plugins/qbsprojectmanager/qbsnodetreebuilder.cpp

@@ -205,13 +205,13 @@ QStringList unreferencedBuildSystemFiles(const qbs::Project &p)
 namespace QbsProjectManager {
 namespace Internal {
 
-QbsRootProjectNode *QbsNodeTreeBuilder::buildTree(QbsProject *project)
+std::unique_ptr<QbsRootProjectNode> QbsNodeTreeBuilder::buildTree(QbsProject *project)
 {
     if (!project->qbsProjectData().isValid())
-        return nullptr;
+        return {};
 
-    auto root = new QbsRootProjectNode(project);
+    auto root = std::make_unique<QbsRootProjectNode>(project);
-    setupProjectNode(root, project->qbsProjectData(), project->qbsProject());
+    setupProjectNode(root.get(), project->qbsProjectData(), project->qbsProject());
     auto buildSystemFiles
             = new ProjectExplorer::FolderNode(project->projectDirectory(),
                                               ProjectExplorer::NodeType::Folder,

src/plugins/qbsprojectmanager/qbsnodetreebuilder.h

@@ -39,7 +39,7 @@ namespace Internal {
 class QbsNodeTreeBuilder
 {
 public:
-    static QbsRootProjectNode *buildTree(QbsProject *project);
+    static std::unique_ptr<QbsRootProjectNode> buildTree(QbsProject *project);
 };
 
 } // namespace Internal

src/plugins/qbsprojectmanager/qbsproject.cpp

@@ -526,9 +526,9 @@ void QbsProject::handleQbsParsingDone(bool success)
 
 void QbsProject::rebuildProjectTree()
 {
-    QbsProjectNode *newRoot = Internal::QbsNodeTreeBuilder::buildTree(this);
+    std::unique_ptr<QbsRootProjectNode> newRoot = Internal::QbsNodeTreeBuilder::buildTree(this);
     setDisplayName(newRoot ? newRoot->displayName() : projectFilePath().toFileInfo().completeBaseName());
-    setRootProjectNode(newRoot);
+    setRootProjectNode(std::move(newRoot));
 }
 
 void QbsProject::handleRuleExecutionDone()

src/plugins/qmakeprojectmanager/qmakenodetreebuilder.cpp

@@ -197,7 +197,7 @@ static void createTree(const QmakePriFile *pri, QmakePriFileNode *node, const Fi
     }
 }
 
-QmakeProFileNode *QmakeNodeTreeBuilder::buildTree(QmakeProject *project)
+std::unique_ptr<QmakeProFileNode> QmakeNodeTreeBuilder::buildTree(QmakeProject *project)
 {
     // Remove qmake implementation details that litter up the project data:
     Target *t = project->activeTarget();
@@ -206,8 +206,9 @@ QmakeProFileNode *QmakeNodeTreeBuilder::buildTree(QmakeProject *project)
 
     const FileNameList toExclude = qt ? qt->directoriesToIgnoreInProjectTree() : FileNameList();
 
-    auto root = new QmakeProFileNode(project, project->projectFilePath(), project->rootProFile());
+    auto root = std::make_unique<QmakeProFileNode>(project, project->projectFilePath(),
-    createTree(project->rootProFile(), root, toExclude);
+                                                   project->rootProFile());
+    createTree(project->rootProFile(), root.get(), toExclude);
 
     return root;
 }

src/plugins/qmakeprojectmanager/qmakenodetreebuilder.h

@@ -37,7 +37,7 @@ namespace QmakeProjectManager {
 class QmakeNodeTreeBuilder
 {
 public:
-    static QmakeProFileNode *buildTree(QmakeProject *project);
+    static std::unique_ptr<QmakeProFileNode> buildTree(QmakeProject *project);
 };
 
 } // namespace QmakeProjectManager

src/plugins/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp

@@ -55,14 +55,14 @@ public:
     {
         ProjectExplorer::FileNode *fileNode
                 = new ProjectExplorer::FileNode(file, ProjectExplorer::FileType::Source, false);
-        DummyProjectNode *root = new DummyProjectNode(file);
+        auto root = std::make_unique<DummyProjectNode>(file);
         root->addNode(fileNode);
         fileNode = new ProjectExplorer::FileNode(
                     Utils::FileName::fromLatin1(
                         ":/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp"),
                     ProjectExplorer::FileType::Source, false);
         root->addNode(fileNode);
-        setRootProjectNode(root);
+        setRootProjectNode(std::move(root));
     }
 
     bool needsConfiguration() const final { return false; }

src/plugins/qmlprojectmanager/qmlproject.cpp

@@ -359,7 +359,7 @@ void QmlProject::generateProjectTree()
     if (!m_projectItem)
         return;
 
-    auto newRoot = new Internal::QmlProjectNode(this);
+    auto newRoot = std::make_unique<Internal::QmlProjectNode>(this);
 
     for (const QString &f : m_projectItem.data()->files()) {
         const Utils::FileName fileName = Utils::FileName::fromString(f);
@@ -369,7 +369,7 @@ void QmlProject::generateProjectTree()
     }
     newRoot->addNestedNode(new FileNode(projectFilePath(), FileType::Project, false));
 
-    setRootProjectNode(newRoot);
+    setRootProjectNode(std::move(newRoot));
     refreshTargetDirectory();
 }