CMakePM: Add action to reload CMake Presets

The CMake presets will be reloaded. The preset kits will get the CMake
configuration cleared (no more CMakeCache.txt)

All the kits will be removed from the project, so that the Kit
configuration wizard will be displayed at the end.

If a normal Qt Kit was configured, the user will get the chance to
import the existing configuration (the initial configuration will be
lost though).

Change-Id: Ieda83098d7716913d7870b67ab522705da4ed93b
Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io>
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>
Reviewed-by: hjk <hjk@qt.io>

src/plugins/cmakeprojectmanager/cmakeproject.cpp

@@ -67,7 +67,7 @@ Tasks CMakeProject::projectIssues(const Kit *k) const
 ProjectImporter *CMakeProject::projectImporter() const
 {
     if (!m_projectImporter)
-        m_projectImporter = new CMakeProjectImporter(projectFilePath(), m_presetsData);
+        m_projectImporter = new CMakeProjectImporter(projectFilePath(), this);
     return m_projectImporter;
 }
 
@@ -306,4 +306,15 @@ void CMakeProject::configureAsExampleProject(ProjectExplorer::Kit *kit)
     setup(infoList);
 }
 
+void CMakeProjectManager::CMakeProject::setOldPresetKits(
+    const QList<ProjectExplorer::Kit *> &presetKits) const
+{
+    m_oldPresetKits = presetKits;
+}
+
+QList<Kit *> CMakeProject::oldPresetKits() const
+{
+    return m_oldPresetKits;
+}
+
 } // namespace CMakeProjectManager

src/plugins/cmakeprojectmanager/cmakeproject.h

@@ -31,6 +31,9 @@ public:
     Internal::PresetsData presetsData() const;
     void readPresets();
 
+    void setOldPresetKits(const QList<ProjectExplorer::Kit *> &presetKits) const;
+    QList<ProjectExplorer::Kit *> oldPresetKits() const;
+
 protected:
     bool setupTarget(ProjectExplorer::Target *t) final;
 
@@ -43,6 +46,7 @@ private:
     void setupBuildPresets(Internal::PresetsData &presetsData);
 
     mutable Internal::CMakeProjectImporter *m_projectImporter = nullptr;
+    mutable QList<ProjectExplorer::Kit*> m_oldPresetKits;
 
     ProjectExplorer::Tasks m_issues;
     Internal::PresetsData m_presetsData;

src/plugins/cmakeprojectmanager/cmakeprojectconstants.h

@@ -17,6 +17,7 @@ const char BUILD_FILE_CONTEXT_MENU[] = "CMakeProject.BuildFileContextMenu";
 const char BUILD_FILE[] = "CMakeProject.BuildFile";
 const char CMAKE_HOME_DIR[] = "CMakeProject.HomeDirectory";
 const char QML_DEBUG_SETTING[] = "CMakeProject.EnableQmlDebugging";
+const char RELOAD_CMAKE_PRESETS[] = "CMakeProject.ReloadCMakePresets";
 
 const char CMAKEFORMATTER_SETTINGS_GROUP[] = "CMakeFormatter";
 const char CMAKEFORMATTER_GENERAL_GROUP[] = "General";

src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp

@@ -5,6 +5,7 @@
 
 #include "cmakebuildconfiguration.h"
 #include "cmakekitinformation.h"
+#include "cmakeproject.h"
 #include "cmakeprojectconstants.h"
 #include "cmakeprojectmanagertr.h"
 #include "cmaketoolmanager.h"
@@ -15,6 +16,7 @@
 #include <projectexplorer/buildinfo.h>
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/projectexplorerconstants.h>
+#include <projectexplorer/target.h>
 #include <projectexplorer/toolchainmanager.h>
 
 #include <qtsupport/qtkitinformation.h>
@@ -92,9 +94,9 @@ static QString uniqueCMakeToolDisplayName(CMakeTool &tool)
 
 // CMakeProjectImporter
 
-CMakeProjectImporter::CMakeProjectImporter(const FilePath &path, const PresetsData &presetsData)
+CMakeProjectImporter::CMakeProjectImporter(const FilePath &path, const CMakeProject *project)
     : QtProjectImporter(path)
-    , m_presetsData(presetsData)
+    , m_project(project)
     , m_presetsTempDir("qtc-cmake-presets-XXXXXXXX")
 {
     useTemporaryKitAspect(CMakeKitAspect::id(),
@@ -119,7 +121,7 @@ FilePaths CMakeProjectImporter::importCandidates()
         candidates << scanDirectory(shadowBuildDirectory.absolutePath(), QString());
     }
 
-    for (const auto &configPreset : m_presetsData.configurePresets) {
+    for (const auto &configPreset : m_project->presetsData().configurePresets) {
         if (configPreset.hidden.value())
             continue;
 
@@ -152,6 +154,21 @@ FilePaths CMakeProjectImporter::importCandidates()
     return finalists;
 }
 
+Target *CMakeProjectImporter::preferredTarget(const QList<Target *> &possibleTargets)
+{
+    for (Kit *kit : m_project->oldPresetKits()) {
+        const bool haveKit = Utils::contains(possibleTargets, [kit](const auto &target) {
+            return target->kit() == kit;
+        });
+
+        if (!haveKit)
+            KitManager::deregisterKit(kit);
+    }
+    m_project->setOldPresetKits({});
+
+    return ProjectImporter::preferredTarget(possibleTargets);
+}
+
 static CMakeConfig configurationFromPresetProbe(
     const FilePath &importPath,
     const FilePath &sourceDirectory,
@@ -618,7 +635,7 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
 
         const QString presetName = importPath.fileName();
         PresetsDetails::ConfigurePreset configurePreset
-            = Utils::findOrDefault(m_presetsData.configurePresets,
+            = Utils::findOrDefault(m_project->presetsData().configurePresets,
                                    [presetName](const PresetsDetails::ConfigurePreset &preset) {
                                        return preset.name == presetName;
                                    });

src/plugins/cmakeprojectmanager/cmakeprojectimporter.h

@@ -11,6 +11,7 @@
 
 namespace CMakeProjectManager {
 
+class CMakeProject;
 class CMakeTool;
 
 namespace Internal {
@@ -20,9 +21,11 @@ struct DirectoryData;
 class CMakeProjectImporter : public QtSupport::QtProjectImporter
 {
 public:
-    CMakeProjectImporter(const Utils::FilePath &path, const Internal::PresetsData &presetsData);
+    CMakeProjectImporter(const Utils::FilePath &path,
+                         const CMakeProjectManager::CMakeProject *project);
 
     Utils::FilePaths importCandidates() final;
+    ProjectExplorer::Target *preferredTarget(const QList<ProjectExplorer::Target *> &possibleTargets) final;
 
 private:
     QList<void *> examineDirectory(const Utils::FilePath &importPath,
@@ -44,7 +47,7 @@ private:
 
     void ensureBuildDirectory(DirectoryData &data, const ProjectExplorer::Kit *k) const;
 
-    Internal::PresetsData m_presetsData;
+    const CMakeProject *m_project;
     Utils::TemporaryDirectory m_presetsTempDir;
 };
 

src/plugins/cmakeprojectmanager/cmakeprojectmanager.cpp

@@ -9,6 +9,7 @@
 #include "cmakeprojectconstants.h"
 #include "cmakeprojectmanagertr.h"
 #include "cmakeprojectnodes.h"
+#include "cmakespecificsettings.h"
 
 #include <coreplugin/actionmanager/actioncontainer.h>
 #include <coreplugin/actionmanager/actionmanager.h>
@@ -16,6 +17,7 @@
 #include <coreplugin/editormanager/ieditor.h>
 #include <coreplugin/icore.h>
 #include <coreplugin/messagemanager.h>
+#include <coreplugin/modemanager.h>
 
 #include <cppeditor/cpptoolsreuse.h>
 
@@ -26,6 +28,8 @@
 #include <projectexplorer/projecttree.h>
 #include <projectexplorer/target.h>
 
+#include <utils/checkablemessagebox.h>
+#include <utils/utilsicons.h>
 #include <utils/parameteraction.h>
 
 #include <QAction>
@@ -42,6 +46,8 @@ CMakeManager::CMakeManager()
     , m_clearCMakeCacheAction(new QAction(QIcon(), Tr::tr("Clear CMake Configuration"), this))
     , m_runCMakeActionContextMenu(new QAction(QIcon(), Tr::tr("Run CMake"), this))
     , m_rescanProjectAction(new QAction(QIcon(), Tr::tr("Rescan Project"), this))
+    , m_reloadCMakePresetsAction(
+          new QAction(Utils::Icons::RELOAD_TOOLBAR.icon(), Tr::tr("Reload CMake Presets"), this))
 {
     Core::ActionContainer *mbuild =
             Core::ActionManager::actionContainer(ProjectExplorer::Constants::M_BUILDPROJECT);
@@ -101,6 +107,15 @@ CMakeManager::CMakeManager()
         rescanProject(ProjectTree::currentBuildSystem());
     });
 
+    command = Core::ActionManager::registerAction(m_reloadCMakePresetsAction,
+                                                  Constants::RELOAD_CMAKE_PRESETS,
+                                                  globalContext);
+    command->setAttribute(Core::Command::CA_Hide);
+    mbuild->addAction(command, ProjectExplorer::Constants::G_BUILD_BUILD);
+    connect(m_reloadCMakePresetsAction, &QAction::triggered, this, [this] {
+        reloadCMakePresets();
+    });
+
     m_buildFileAction = new Utils::ParameterAction(Tr::tr("Build File"),
                                                    Tr::tr("Build File \"%1\""),
                                                    Utils::ParameterAction::AlwaysEnabled,
@@ -135,6 +150,16 @@ void CMakeManager::updateCmakeActions(Node *node)
     m_runCMakeActionContextMenu->setEnabled(visible);
     m_clearCMakeCacheAction->setVisible(visible);
     m_rescanProjectAction->setVisible(visible);
+
+    const bool reloadPresetsVisible = [project] {
+        if (!project)
+            return false;
+        const FilePath presetsPath = project->projectFilePath().parentDir().pathAppended(
+            "CMakePresets.json");
+        return presetsPath.exists();
+    }();
+    m_reloadCMakePresetsAction->setVisible(reloadPresetsVisible);
+
     enableBuildFileMenus(node);
 }
 
@@ -204,6 +229,70 @@ void CMakeManager::enableBuildFileMenus(Node *node)
     }
 }
 
+void CMakeManager::reloadCMakePresets()
+{
+    auto settings = CMakeSpecificSettings::instance();
+    bool doNotAsk = !settings->askBeforePresetsReload.value();
+    if (!doNotAsk) {
+        CheckableMessageBox question(Core::ICore::dialogParent());
+
+        question.setIcon(QMessageBox::Question);
+        question.setWindowTitle(Tr::tr("Reload CMake Presets"));
+        question.setText(Tr::tr("Re-generates the CMake presets kits. The manual CMake project modifications will be lost."));
+        question.setCheckBoxText(Tr::tr("Do not ask again"));
+        question.setCheckBoxVisible(true);
+        question.setChecked(doNotAsk);
+        question.setStandardButtons(QDialogButtonBox::Cancel);
+
+        question.addButton(Tr::tr("Reload"), QDialogButtonBox::YesRole);
+        question.setDefaultButton(QDialogButtonBox::Yes);
+        question.exec();
+
+        doNotAsk = question.isChecked();
+
+        settings->askBeforePresetsReload.setValue(!doNotAsk);
+        settings->writeSettings(Core::ICore::settings());
+
+        if (question.clickedStandardButton() == QDialogButtonBox::Cancel)
+            return;
+    }
+
+    CMakeProject *project = static_cast<CMakeProject *>(ProjectTree::currentProject());
+    if (!project)
+        return;
+
+    const QSet<QString> oldPresets = Utils::transform<QSet>(project->presetsData().configurePresets,
+                                                            [](const auto &preset) {
+                                                                return preset.name;
+                                                            });
+    project->readPresets();
+
+    QList<Kit*> oldKits;
+    for (const auto &target : project->targets()) {
+        const CMakeConfigItem presetItem = CMakeConfigurationKitAspect::cmakePresetConfigItem(
+            target->kit());
+
+        if (BuildManager::isBuilding(target))
+            BuildManager::cancel();
+
+        // Only clear the CMake configuration for preset kits. Any manual kit configuration
+        // will get the chance to get imported afterwards in the Kit selection wizard
+        CMakeBuildSystem *bs = static_cast<CMakeBuildSystem *>(target->buildSystem());
+        if (!presetItem.isNull() && bs)
+            bs->clearCMakeCache();
+
+        if (!presetItem.isNull() && oldPresets.contains(QString::fromUtf8(presetItem.value)))
+            oldKits << target->kit();
+
+        project->removeTarget(target);
+    }
+
+    project->setOldPresetKits(oldKits);
+
+    Core::ModeManager::activateMode(ProjectExplorer::Constants::MODE_SESSION);
+    Core::ModeManager::setFocusToCurrentMode();
+}
+
 void CMakeManager::buildFile(Node *node)
 {
     if (!node) {

src/plugins/cmakeprojectmanager/cmakeprojectmanager.h

@@ -30,12 +30,14 @@ private:
     void buildFile(ProjectExplorer::Node *node = nullptr);
     void updateBuildFileAction();
     void enableBuildFileMenus(ProjectExplorer::Node *node);
+    void reloadCMakePresets();
 
     QAction *m_runCMakeAction;
     QAction *m_clearCMakeCacheAction;
     QAction *m_runCMakeActionContextMenu;
     QAction *m_rescanProjectAction;
     QAction *m_buildFileContextMenu;
+    QAction *m_reloadCMakePresetsAction;
     Utils::ParameterAction *m_buildFileAction;
 };
 

src/plugins/cmakeprojectmanager/cmakespecificsettings.cpp

@@ -38,6 +38,7 @@ CMakeSpecificSettings::CMakeSpecificSettings()
             autorunCMake,
             packageManagerAutoSetup,
             askBeforeReConfigureInitialParams,
+            askBeforePresetsReload,
             showSourceSubFolders,
             showAdvancedOptionsByDefault,
             st
@@ -77,6 +78,11 @@ CMakeSpecificSettings::CMakeSpecificSettings()
     askBeforeReConfigureInitialParams.setLabelText(::CMakeProjectManager::Tr::tr("Ask before re-configuring with "
         "initial parameters"));
 
+    registerAspect(&askBeforePresetsReload);
+    askBeforePresetsReload.setSettingsKey("AskBeforePresetsReload");
+    askBeforePresetsReload.setDefaultValue(true);
+    askBeforePresetsReload.setLabelText(::CMakeProjectManager::Tr::tr("Ask before reloading CMake Presets"));
+
     registerAspect(&showSourceSubFolders);
     showSourceSubFolders.setSettingsKey("ShowSourceSubFolders");
     showSourceSubFolders.setDefaultValue(true);

src/plugins/cmakeprojectmanager/cmakespecificsettings.h

@@ -18,6 +18,7 @@ public:
     Utils::StringAspect ninjaPath;
     Utils::BoolAspect packageManagerAutoSetup;
     Utils::BoolAspect askBeforeReConfigureInitialParams;
+    Utils::BoolAspect askBeforePresetsReload;
     Utils::BoolAspect showSourceSubFolders;
     Utils::BoolAspect showAdvancedOptionsByDefault;
 };