ProjectExplorer: Settle on fixed set of build step lists

Even if the implementation allowed different lists than 'build'
and 'clean', that's the only set that has been used, ever.

If really needed, this could be re-instated, but for now having
them fixed removes part of the neeed for a two-phase construction
and helps to simplify user code.

Change-Id: I3df09a1829a7d020ef8963d358ea80f8d199ba13
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/android/androidbuildapkstep.cpp

@@ -138,7 +138,7 @@ AndroidBuildApkStep *AndroidBuildApkStep::findInBuild(const BuildConfiguration *
 {
     if (!bc)
         return nullptr;
-    BuildStepList *bsl = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+    BuildStepList *bsl = bc->buildSteps();
     QTC_ASSERT(bsl, return nullptr);
     return bsl->firstOfType<AndroidBuildApkStep>();
 }

src/plugins/autotoolsprojectmanager/autotoolsbuildconfiguration.cpp

@@ -57,27 +57,22 @@ AutotoolsBuildConfiguration::AutotoolsBuildConfiguration(Target *parent, Core::I
 
 void AutotoolsBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
-
-    BuildStepList *buildSteps = stepList(BUILDSTEPS_BUILD);
-
     // ### Build Steps Build ###
     // autogen.sh or autoreconf
     QFile autogenFile(target()->project()->projectDirectory().toString() + "/autogen.sh");
     if (autogenFile.exists())
-        buildSteps->appendStep(Constants::AUTOGEN_STEP_ID);
+        buildSteps()->appendStep(Constants::AUTOGEN_STEP_ID);
     else
-        buildSteps->appendStep(Constants::AUTORECONF_STEP_ID);
+        buildSteps()->appendStep(Constants::AUTORECONF_STEP_ID);
 
     // ./configure.
-    buildSteps->appendStep(Constants::CONFIGURE_STEP_ID);
+    buildSteps()->appendStep(Constants::CONFIGURE_STEP_ID);
 
     // make
-    buildSteps->appendStep(Constants::MAKE_STEP_ID);
+    buildSteps()->appendStep(Constants::MAKE_STEP_ID);
 
     // ### Build Steps Clean ###
-    BuildStepList *cleanSteps = stepList(BUILDSTEPS_CLEAN);
+    cleanSteps()->appendStep(Constants::MAKE_STEP_ID);
-    cleanSteps->appendStep(Constants::MAKE_STEP_ID);
 }
 
 

src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp

@@ -99,15 +99,12 @@ CMakeBuildConfiguration::~CMakeBuildConfiguration()
 
 void CMakeBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
+    buildSteps()->appendStep(Constants::CMAKE_BUILD_STEP_ID);
-
-    BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
-    buildSteps->appendStep(Constants::CMAKE_BUILD_STEP_ID);
 
     if (DeviceTypeKitAspect::deviceTypeId(target()->kit())
             == Android::Constants::ANDROID_DEVICE_TYPE) {
-        buildSteps->appendStep(Android::Constants::ANDROID_BUILD_APK_ID);
+        buildSteps()->appendStep(Android::Constants::ANDROID_BUILD_APK_ID);
-        const auto &bs = buildSteps->steps().constLast();
+        const auto &bs = buildSteps()->steps().constLast();
         m_initialConfiguration.prepend(CMakeProjectManager::CMakeConfigItem{"ANDROID_NATIVE_API_LEVEL",
                                                                             CMakeProjectManager::CMakeConfigItem::Type::STRING,
                                                                             "Android native API level",
@@ -157,8 +154,7 @@ void CMakeBuildConfiguration::initialize()
         m_initialConfiguration.prepend(CMakeProjectManager::CMakeConfigItem{"CMAKE_FIND_ROOT_PATH", "%{Qt:QT_INSTALL_PREFIX}"});
     }
 
-    BuildStepList *cleanSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
+    cleanSteps()->appendStep(Constants::CMAKE_BUILD_STEP_ID);
-    cleanSteps->appendStep(Constants::CMAKE_BUILD_STEP_ID);
 
     if (initialBuildDirectory().isEmpty()) {
         auto project = target()->project();
@@ -224,9 +220,8 @@ FilePath CMakeBuildConfiguration::shadowBuildDirectory(const FilePath &projectFi
 
 void CMakeBuildConfiguration::buildTarget(const QString &buildTarget)
 {
-    const Core::Id buildStep = ProjectExplorer::Constants::BUILDSTEPS_BUILD;
     auto cmBs = qobject_cast<CMakeBuildStep *>(Utils::findOrDefault(
-                                                   stepList(buildStep)->steps(),
+                                                   buildSteps()->steps(),
                                                    [](const ProjectExplorer::BuildStep *bs) {
         return bs->id() == Constants::CMAKE_BUILD_STEP_ID;
     }));
@@ -237,7 +232,7 @@ void CMakeBuildConfiguration::buildTarget(const QString &buildTarget)
         cmBs->setBuildTarget(buildTarget);
     }
 
-    BuildManager::buildList(stepList(buildStep));
+    BuildManager::buildList(buildSteps());
 
     if (cmBs)
         cmBs->setBuildTarget(originalBuildTarget);
@@ -294,7 +289,7 @@ void CMakeBuildConfiguration::setConfigurationForCMake(const QList<ConfigModel::
         // We always need to clean when we change the ANDROID_BUILD_ABI_ variables
         QList<ProjectExplorer::BuildStepList *> stepLists;
         const Core::Id clean = ProjectExplorer::Constants::BUILDSTEPS_CLEAN;
-        stepLists << stepList(clean);
+        stepLists << cleanSteps();
         BuildManager::buildLists(stepLists, QStringList() << ProjectExplorerPlugin::displayNameForStepId(clean));
     }
 }

src/plugins/cmakeprojectmanager/cmakelocatorfilter.cpp

@@ -146,8 +146,8 @@ void BuildCMakeTargetLocatorFilter::accept(Core::LocatorFilterEntry selection,
         return;
 
     // Find the make step
-    BuildStepList *buildStepList = cmakeProject->activeTarget()->activeBuildConfiguration()->stepList(
+    BuildStepList *buildStepList =
-        ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+            cmakeProject->activeTarget()->activeBuildConfiguration()->buildSteps();
     auto buildStep = buildStepList->firstOfType<CMakeBuildStep>();
     if (!buildStep)
         return;

src/plugins/cmakeprojectmanager/cmakeproject.cpp

@@ -133,8 +133,7 @@ MakeInstallCommand CMakeProject::makeInstallCommand(const Target *target,
 {
     MakeInstallCommand cmd;
     if (const BuildConfiguration * const bc = target->activeBuildConfiguration()) {
-        if (const auto cmakeStep = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD)
+        if (const auto cmakeStep = bc->buildSteps()->firstOfType<CMakeBuildStep>()) {
-                ->firstOfType<CMakeBuildStep>()) {
             if (CMakeTool *tool = CMakeKitAspect::cmakeTool(target->kit()))
                 cmd.command = tool->cmakeExecutable();
         }

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.h

@@ -100,6 +100,7 @@ class CompilationDatabaseBuildConfiguration : public ProjectExplorer::BuildConfi
     Q_OBJECT
 public:
     CompilationDatabaseBuildConfiguration(ProjectExplorer::Target *target, Core::Id id);
+    void initialize() final {}
 };
 
 class CompilationDatabaseBuildConfigurationFactory

src/plugins/genericprojectmanager/genericbuildconfiguration.cpp

@@ -60,13 +60,8 @@ GenericBuildConfiguration::GenericBuildConfiguration(Target *parent, Core::Id id
 
 void GenericBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
+    buildSteps()->appendStep(Constants::GENERIC_MS_ID);
-
+    cleanSteps()->appendStep(Constants::GENERIC_MS_ID);
-    BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
-    buildSteps->appendStep(Constants::GENERIC_MS_ID);
-
-    BuildStepList *cleanSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
-    cleanSteps->appendStep(Constants::GENERIC_MS_ID);
 
     updateCacheAndEmitEnvironmentChanged();
 }

src/plugins/nim/project/nimblebuildconfiguration.cpp

@@ -65,8 +65,6 @@ BuildConfiguration::BuildType NimbleBuildConfiguration::buildType() const
 
 void NimbleBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
-
     m_buildType = initialBuildType();
 
     setBuildDirectory(project()->projectDirectory());
@@ -78,8 +76,7 @@ void NimbleBuildConfiguration::initialize()
 //    // Don't add a nimble build step when the package has no binaries (i.e a library package)
 //    if (!m_nimbleBuildSystem->metadata().bin.empty())
 //    {
-        BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+        buildSteps()->appendStep(new NimbleBuildStep(buildSteps()));
-        buildSteps->appendStep(new NimbleBuildStep(buildSteps));
 //    }
 }
 

src/plugins/nim/project/nimbuildconfiguration.cpp

@@ -75,8 +75,6 @@ NimBuildConfiguration::NimBuildConfiguration(Target *target, Core::Id id)
 
 void NimBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
-
     // Create the build configuration and initialize it from build info
     setBuildDirectory(defaultBuildDirectory(target()->kit(),
                                             project()->projectFilePath(),
@@ -85,8 +83,7 @@ void NimBuildConfiguration::initialize()
 
     // Add nim compiler build step
     {
-        BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+        auto nimCompilerBuildStep = new NimCompilerBuildStep(buildSteps());
-        auto nimCompilerBuildStep = new NimCompilerBuildStep(buildSteps);
         NimCompilerBuildStep::DefaultBuildOptions defaultOption;
         switch (initialBuildType()) {
         case BuildConfiguration::Release:
@@ -107,14 +104,11 @@ void NimBuildConfiguration::initialize()
 
         if (!nimFiles.isEmpty())
             nimCompilerBuildStep->setTargetNimFile(nimFiles.first());
-        buildSteps->appendStep(nimCompilerBuildStep);
+        buildSteps()->appendStep(nimCompilerBuildStep);
     }
 
     // Add clean step
-    {
+    cleanSteps()->appendStep(Constants::C_NIMCOMPILERCLEANSTEP_ID);
-        BuildStepList *cleanSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
-        cleanSteps->appendStep(Constants::C_NIMCOMPILERCLEANSTEP_ID);
-    }
 }
 
 FilePath NimBuildConfiguration::cacheDirectory() const
@@ -131,9 +125,7 @@ FilePath NimBuildConfiguration::outFilePath() const
 
 const NimCompilerBuildStep *NimBuildConfiguration::nimCompilerBuildStep() const
 {
-    BuildStepList *steps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+    foreach (BuildStep *step, buildSteps()->steps())
-    QTC_ASSERT(steps, return nullptr);
-    foreach (BuildStep *step, steps->steps())
         if (step->id() == Constants::C_NIMCOMPILERBUILDSTEP_ID)
             return qobject_cast<NimCompilerBuildStep *>(step);
     return nullptr;

src/plugins/projectexplorer/buildconfiguration.cpp

@@ -69,9 +69,15 @@ namespace Internal {
 class BuildConfigurationPrivate
 {
 public:
+    BuildConfigurationPrivate(BuildConfiguration *bc)
+        : m_buildSteps(bc, Constants::BUILDSTEPS_BUILD),
+          m_cleanSteps(bc, Constants::BUILDSTEPS_CLEAN)
+    {}
+
     bool m_clearSystemEnvironment = false;
     Utils::EnvironmentItems m_userEnvironmentChanges;
-    QList<BuildStepList *> m_stepLists;
+    BuildStepList m_buildSteps;
+    BuildStepList m_cleanSteps;
     BuildDirectoryAspect *m_buildDirectoryAspect = nullptr;
     Utils::FilePath m_lastEmittedBuildDirectory;
     mutable Utils::Environment m_cachedEnvironment;
@@ -88,7 +94,7 @@ public:
 } // Internal
 
 BuildConfiguration::BuildConfiguration(Target *target, Core::Id id)
-    : ProjectConfiguration(target, id), d(new Internal::BuildConfigurationPrivate)
+    : ProjectConfiguration(target, id), d(new Internal::BuildConfigurationPrivate(this))
 {
     QTC_CHECK(target && target == this->target());
 
@@ -167,8 +173,8 @@ void BuildConfiguration::addConfigWidgets(const std::function<void(NamedWidget *
     if (NamedWidget *generalConfigWidget = createConfigWidget())
         adder(generalConfigWidget);
 
-    adder(new Internal::BuildStepListWidget(stepList(Constants::BUILDSTEPS_BUILD)));
+    adder(new Internal::BuildStepListWidget(buildSteps()));
-    adder(new Internal::BuildStepListWidget(stepList(Constants::BUILDSTEPS_CLEAN)));
+    adder(new Internal::BuildStepListWidget(cleanSteps()));
 
     QList<NamedWidget *> subConfigWidgets = createSubConfigWidgets();
     foreach (NamedWidget *subConfigWidget, subConfigWidgets)
@@ -203,12 +209,6 @@ NamedWidget *BuildConfiguration::createConfigWidget()
     return named;
 }
 
-void BuildConfiguration::initialize()
-{
-    d->m_stepLists.append(new BuildStepList(this, Constants::BUILDSTEPS_BUILD));
-    d->m_stepLists.append(new BuildStepList(this, Constants::BUILDSTEPS_CLEAN));
-}
-
 QList<NamedWidget *> BuildConfiguration::createSubConfigWidgets()
 {
     return {new BuildEnvironmentWidget(this)};
@@ -220,25 +220,26 @@ BuildSystem *BuildConfiguration::buildSystem() const
     return target()->fallbackBuildSystem();
 }
 
-QList<Core::Id> BuildConfiguration::knownStepLists() const
+BuildStepList *BuildConfiguration::buildSteps() const
 {
-    return Utils::transform(d->m_stepLists, &BuildStepList::id);
+    return &d->m_buildSteps;
 }
 
-BuildStepList *BuildConfiguration::stepList(Core::Id id) const
+BuildStepList *BuildConfiguration::cleanSteps() const
 {
-    return Utils::findOrDefault(d->m_stepLists, Utils::equal(&BuildStepList::id, id));
+    return &d->m_cleanSteps;
 }
 
 QVariantMap BuildConfiguration::toMap() const
 {
-    QVariantMap map(ProjectConfiguration::toMap());
+    QVariantMap map = ProjectConfiguration::toMap();
+
     map.insert(QLatin1String(CLEAR_SYSTEM_ENVIRONMENT_KEY), d->m_clearSystemEnvironment);
     map.insert(QLatin1String(USER_ENVIRONMENT_CHANGES_KEY), Utils::EnvironmentItem::toStringList(d->m_userEnvironmentChanges));
 
-    map.insert(QLatin1String(BUILD_STEP_LIST_COUNT), d->m_stepLists.count());
+    map.insert(QLatin1String(BUILD_STEP_LIST_COUNT), 2);
-    for (int i = 0; i < d->m_stepLists.count(); ++i)
+    map.insert(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(0), d->m_buildSteps.toMap());
-        map.insert(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(i), d->m_stepLists.at(i)->toMap());
+    map.insert(QLatin1String(BUILD_STEP_LIST_PREFIX) + QString::number(1), d->m_cleanSteps.toMap());
 
     return map;
 }
@@ -250,8 +251,8 @@ bool BuildConfiguration::fromMap(const QVariantMap &map)
 
     updateCacheAndEmitEnvironmentChanged();
 
-    qDeleteAll(d->m_stepLists);
+    d->m_buildSteps.clear();
-    d->m_stepLists.clear();
+    d->m_cleanSteps.clear();
 
     int maxI = map.value(QLatin1String(BUILD_STEP_LIST_COUNT), 0).toInt();
     for (int i = 0; i < maxI; ++i) {
@@ -260,19 +261,18 @@ bool BuildConfiguration::fromMap(const QVariantMap &map)
             qWarning() << "No data for build step list" << i << "found!";
             continue;
         }
-        auto list = new BuildStepList(this, idFromMap(data));
+        Core::Id id = idFromMap(data);
-        if (!list->fromMap(data)) {
+        if (id == Constants::BUILDSTEPS_BUILD) {
-            qWarning() << "Failed to restore build step list" << i;
+            if (!d->m_buildSteps.fromMap(data))
-            delete list;
+                qWarning() << "Failed to restore build step list";
-            return false;
+        } else if (id == Constants::BUILDSTEPS_CLEAN) {
+            if (!d->m_cleanSteps.fromMap(data))
+                qWarning() << "Failed to restore clean step list";
+        } else {
+            qWarning() << "Ignoring unknown step list";
         }
-        d->m_stepLists.append(list);
     }
 
-    // We currently assume there to be at least a clean and build list!
-    QTC_CHECK(knownStepLists().contains(Core::Id(Constants::BUILDSTEPS_BUILD)));
-    QTC_CHECK(knownStepLists().contains(Core::Id(Constants::BUILDSTEPS_CLEAN)));
-
     return ProjectConfiguration::fromMap(map);
 }
 

src/plugins/projectexplorer/buildconfiguration.h

@@ -77,8 +77,8 @@ public:
 
     virtual void addToEnvironment(Utils::Environment &env) const;
 
-    QList<Core::Id> knownStepLists() const;
+    BuildStepList *buildSteps() const;
-    BuildStepList *stepList(Core::Id id) const;
+    BuildStepList *cleanSteps() const;
 
     bool fromMap(const QVariantMap &map) override;
     QVariantMap toMap() const override;
@@ -125,7 +125,7 @@ signals:
     void buildTypeChanged();
 
 protected:
-    virtual void initialize();
+    virtual void initialize() = 0;
 
 private:
     void emitBuildDirectoryChanged();

src/plugins/projectexplorer/project.cpp

@@ -896,10 +896,8 @@ MakeInstallCommand Project::makeInstallCommand(const Target *target, const QStri
     QTC_ASSERT(hasMakeInstallEquivalent(), return MakeInstallCommand());
     MakeInstallCommand cmd;
     if (const BuildConfiguration * const bc = target->activeBuildConfiguration()) {
-        if (const auto makeStep = bc->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD)
+        if (const auto makeStep = bc->buildSteps()->firstOfType<MakeStep>())
-                ->firstOfType<MakeStep>()) {
             cmd.command = makeStep->makeExecutable();
-        }
     }
     cmd.arguments << "install" << ("INSTALL_ROOT=" + QDir::toNativeSeparators(installRoot));
     return cmd;

src/plugins/projectexplorer/projectexplorer.cpp

@@ -2670,11 +2670,13 @@ int ProjectExplorerPluginPrivate::queue(QList<Project *> projects, QList<Id> ste
             if (!pro || pro->needsConfiguration())
                 continue;
             BuildStepList *bsl = nullptr;
-            if (id == Constants::BUILDSTEPS_DEPLOY
+            Target *target = pro->activeTarget();
-                && pro->activeTarget()->activeDeployConfiguration())
+            if (id == Constants::BUILDSTEPS_DEPLOY && target->activeDeployConfiguration())
-                bsl = pro->activeTarget()->activeDeployConfiguration()->stepList();
+                bsl = target->activeDeployConfiguration()->stepList();
-            else if (pro->activeTarget()->activeBuildConfiguration())
+            else if (id == Constants::BUILDSTEPS_BUILD && target->activeBuildConfiguration())
-                bsl = pro->activeTarget()->activeBuildConfiguration()->stepList(id);
+                bsl = target->activeBuildConfiguration()->buildSteps();
+            else if (id == Constants::BUILDSTEPS_CLEAN && target->activeBuildConfiguration())
+                bsl = target->activeBuildConfiguration()->cleanSteps();
 
             if (!bsl || bsl->isEmpty())
                 continue;

src/plugins/qbsprojectmanager/qbsbuildconfiguration.cpp

@@ -126,8 +126,6 @@ BuildSystem *QbsBuildConfiguration::buildSystem() const
 
 void QbsBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
-
     QVariantMap configData = extraInfo().value<QVariantMap>();
     configData.insert(QLatin1String(Constants::QBS_CONFIG_VARIANT_KEY),
                       (initialBuildType() == BuildConfiguration::Debug)
@@ -159,13 +157,11 @@ void QbsBuildConfiguration::initialize()
 
     m_configurationName->setValue(uniqueConfigName);
 
-    BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+    auto bs = new QbsBuildStep(buildSteps());
-    auto bs = new QbsBuildStep(buildSteps);
     bs->setQbsConfiguration(bd);
-    buildSteps->appendStep(bs);
+    buildSteps()->appendStep(bs);
 
-    BuildStepList *cleanSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
+    cleanSteps()->appendStep(Constants::QBS_CLEANSTEP_ID);
-    cleanSteps->appendStep(Constants::QBS_CLEANSTEP_ID);
 
     emit qbsConfigurationChanged();
 }
@@ -204,7 +200,7 @@ void QbsBuildConfiguration::restrictNextBuild(const RunConfiguration *rc)
 
 QbsBuildStep *QbsBuildConfiguration::qbsStep() const
 {
-    return stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD)->firstOfType<QbsBuildStep>();
+    return buildSteps()->firstOfType<QbsBuildStep>();
 }
 
 QVariantMap QbsBuildConfiguration::qbsConfiguration() const

src/plugins/qbsprojectmanager/qbsprojectmanagerplugin.cpp

@@ -513,9 +513,7 @@ void QbsProjectManagerPlugin::buildFiles(QbsProject *project, const QStringList
     bc->setActiveFileTags(activeFileTags);
     bc->setProducts(QStringList());
 
-    const Core::Id buildStep = ProjectExplorer::Constants::BUILDSTEPS_BUILD;
+    BuildManager::buildList(bc->buildSteps());
-
-    BuildManager::buildList(bc->stepList(buildStep));
 
     bc->setChangedFiles(QStringList());
     bc->setActiveFileTags(QStringList());
@@ -549,8 +547,13 @@ void QbsProjectManagerPlugin::runStepsForProducts(QbsProject *project,
     QList<ProjectExplorer::BuildStepList *> stepLists;
     QStringList stepListNames;
     for (const Core::Id &stepType : stepTypes) {
-        stepLists << bc->stepList(stepType);
+        if (stepType == ProjectExplorer::Constants::BUILDSTEPS_BUILD) {
-        stepListNames <<ProjectExplorerPlugin::displayNameForStepId(stepType);
+            stepLists << bc->buildSteps();
+            stepListNames << ProjectExplorerPlugin::displayNameForStepId(stepType);
+        } else if (stepType == ProjectExplorer::Constants::BUILDSTEPS_CLEAN) {
+            stepLists << bc->cleanSteps();
+            stepListNames << ProjectExplorerPlugin::displayNameForStepId(stepType);
+        }
     }
     BuildManager::buildLists(stepLists, stepListNames);
     bc->setProducts(QStringList());

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp

@@ -155,15 +155,11 @@ QmakeBuildConfiguration::QmakeBuildConfiguration(Target *target, Core::Id id)
 
 void QmakeBuildConfiguration::initialize()
 {
-    BuildConfiguration::initialize();
+    auto qmakeStep = new QMakeStep(buildSteps());
+    buildSteps()->appendStep(qmakeStep);
+    buildSteps()->appendStep(Constants::MAKESTEP_BS_ID);
 
-    BuildStepList *buildSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
+    cleanSteps()->appendStep(Constants::MAKESTEP_BS_ID);
-    auto qmakeStep = new QMakeStep(buildSteps);
-    buildSteps->appendStep(qmakeStep);
-    buildSteps->appendStep(Constants::MAKESTEP_BS_ID);
-
-    BuildStepList *cleanSteps = stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN);
-    cleanSteps->appendStep(Constants::MAKESTEP_BS_ID);
 
     const QmakeExtraBuildInfo qmakeExtra = extraInfo().value<QmakeExtraBuildInfo>();
     BaseQtVersion *version = QtKitAspect::qtVersion(target()->kit());
@@ -195,8 +191,8 @@ void QmakeBuildConfiguration::initialize()
 
     if (DeviceTypeKitAspect::deviceTypeId(target()->kit())
             == Android::Constants::ANDROID_DEVICE_TYPE) {
-        buildSteps->appendStep(Android::Constants::ANDROID_PACKAGE_INSTALLATION_STEP_ID);
+        buildSteps()->appendStep(Android::Constants::ANDROID_PACKAGE_INSTALLATION_STEP_ID);
-        buildSteps->appendStep(Android::Constants::ANDROID_BUILD_APK_ID);
+        buildSteps()->appendStep(Android::Constants::ANDROID_BUILD_APK_ID);
     }
 
     updateCacheAndEmitEnvironmentChanged();
@@ -469,8 +465,7 @@ QStringList QmakeBuildConfiguration::configCommandLineArguments() const
 QMakeStep *QmakeBuildConfiguration::qmakeStep() const
 {
     QMakeStep *qs = nullptr;
-    BuildStepList *bsl = stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_BUILD));
+    BuildStepList *bsl = buildSteps();
-    Q_ASSERT(bsl);
     for (int i = 0; i < bsl->count(); ++i)
         if ((qs = qobject_cast<QMakeStep *>(bsl->at(i))) != nullptr)
             return qs;
@@ -480,8 +475,7 @@ QMakeStep *QmakeBuildConfiguration::qmakeStep() const
 QmakeMakeStep *QmakeBuildConfiguration::makeStep() const
 {
     QmakeMakeStep *ms = nullptr;
-    BuildStepList *bsl = stepList(Core::Id(ProjectExplorer::Constants::BUILDSTEPS_BUILD));
+    BuildStepList *bsl = buildSteps();
-    Q_ASSERT(bsl);
     for (int i = 0; i < bsl->count(); ++i)
         if ((ms = qobject_cast<QmakeMakeStep *>(bsl->at(i))) != nullptr)
             return ms;
@@ -863,7 +857,7 @@ bool QmakeBuildConfiguration::regenerateBuildFiles(Node *node)
 
     qs->setForced(true);
 
-    BuildManager::buildList(stepList(ProjectExplorer::Constants::BUILDSTEPS_CLEAN));
+    BuildManager::buildList(cleanSteps());
     BuildManager::appendStep(qs, ProjectExplorerPlugin::displayNameForStepId(ProjectExplorer::Constants::BUILDSTEPS_CLEAN));
 
     QmakeProFileNode *proFile = nullptr;

src/plugins/qmakeprojectmanager/qmakeprojectmanager.cpp

@@ -237,17 +237,15 @@ void QmakeManager::handleSubDirContextMenu(QmakeManager::Action action, bool isF
         const Core::Id buildStep = ProjectExplorer::Constants::BUILDSTEPS_BUILD;
         const Core::Id cleanStep = ProjectExplorer::Constants::BUILDSTEPS_CLEAN;
         if (action == BUILD) {
-            BuildManager::buildList(bc->stepList(buildStep));
+            BuildManager::buildList(bc->buildSteps());
         } else if (action == CLEAN) {
-            BuildManager::buildList(bc->stepList(cleanStep));
+            BuildManager::buildList(bc->cleanSteps());
         } else if (action == REBUILD) {
             QStringList names;
             names << ProjectExplorerPlugin::displayNameForStepId(cleanStep)
                   << ProjectExplorerPlugin::displayNameForStepId(buildStep);
 
-            QList<ProjectExplorer::BuildStepList *> stepLists;
+            BuildManager::buildLists({bc->cleanSteps(), bc->buildSteps()}, names);
-            stepLists << bc->stepList(cleanStep) << bc->stepList(buildStep);
-            BuildManager::buildLists(stepLists, names);
         }
     }
 

src/plugins/qmakeprojectmanager/qmakestep.cpp

@@ -575,7 +575,7 @@ QMakeStepConfigWidget::QMakeStepConfigWidget(QMakeStep *step)
 
         QList<ProjectExplorer::BuildStepList *> stepLists;
         const Core::Id clean = ProjectExplorer::Constants::BUILDSTEPS_CLEAN;
-        stepLists << bc->stepList(clean);
+        stepLists << bc->cleanSteps();
         BuildManager::buildLists(stepLists, {ProjectExplorerPlugin::displayNameForStepId(clean)});
     });
     auto chooser = new Core::VariableChooser(qmakeAdditonalArgumentsLineEdit);
@@ -758,11 +758,10 @@ void QMakeStepConfigWidget::recompileMessageBoxFinished(int button)
         if (!bc)
             return;
 
-        QList<ProjectExplorer::BuildStepList *> stepLists;
         const Core::Id clean = ProjectExplorer::Constants::BUILDSTEPS_CLEAN;
         const Core::Id build = ProjectExplorer::Constants::BUILDSTEPS_BUILD;
-        stepLists << bc->stepList(clean) << bc->stepList(build);
+        BuildManager::buildLists({bc->cleanSteps(), bc->buildSteps()},
-        BuildManager::buildLists(stepLists, QStringList() << ProjectExplorerPlugin::displayNameForStepId(clean)
+                                 QStringList() << ProjectExplorerPlugin::displayNameForStepId(clean)
                        << ProjectExplorerPlugin::displayNameForStepId(build));
     }
 }

src/plugins/remotelinux/makeinstallstep.cpp

@@ -148,12 +148,12 @@ bool MakeInstallStep::init()
         processParameters()->setEnvironment(env);
     }
     m_noInstallTarget = false;
-    const auto buildStep = buildConfiguration()
+
-            ->stepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD)
+    const auto buildStep = buildConfiguration()->buildSteps()->firstOfType<AbstractProcessStep>();
-            ->firstOfType<AbstractProcessStep>();
     m_isCmakeProject = buildStep
             && buildStep->processParameters()->command().executable().toString()
             .contains("cmake");
+
     return true;
 }