Commit 53a15107 authored by hjk's avatar hjk

ProjectExplorer/all: Re-organize BuildSteps/{Deploy,Build}Config setup

This follow the rough pattern of recent *RunConfigurationFactory changes
for build and deploy configurations.

- Collapse the two lines of constructors similar to what
  890c1906 did for RunConfigurations
  * Deploy* was purely mechanical
  * Build* ctors are split in connects() in the ctor body
    to create "empty shell for clone" etc
    and build step additions in initialize() functions which
    are only used in the create() case.
  -- Allows to collapse the shared 'ctor()' functions, too.

- Move FooBuildConfigurationFactory::create() implementations
  to FooBuildConfiguration() constructor. That was a strange
  and unneeded ping-pong between factories and objects, and
  furthermore allows one level less of indirection (and for a
  later, left out here, some reduction of the
  FooBuildConfiguration interfaces that were only used to
  accommodate the *Factory::create() functions.

- Most {Build,Deploy}Configuration{,Factory} classes had a canHandle(),
  but there wasn't one in the base classses. Have one there.

- Most canHandle() functions were checking simple restrictions on
  e.g. project or target types, specify those by setters in the
  constructors instead and check them in the base canHandle()

- clone() is generally replaced by a creation of a "shell object"
  and a fromMap(source->toMap()), implemented in the base, there
  are two cases left for Android and Qbs that needed(?) some extra
  polish

- generally use canHandle() in base implementation, instead
  of doing that in all Derived::canFoo()

- as a result, canCreate/create/canClone/clone reimplementations
  are not needed anymore, keep the base implementation for
  now (could be inlined into their only users later), but
  de-virtualize them.

- Combine Ios{Preset,DSym}BuildStepFactory. There was only one
  'dsym' build step they could create.

- Split the 'mangled' id into the ProjectConfiguration subtype
  specific constant identifier, and a QString extraId() bit.
  Only maintain the mangled id in saved settings.

- Make ProjectConfiguration::m_id a constant member, adapt
  all constructors of derived classe.

Not done in this patch:

- Finish possible cosmetic changes on top

- Add a way to specify restrictions to supported Qt versions
  (used in Android/Ios), as the base implementation does not
  depend on the qtsupport plugin

- Combine the QList<X> availableFoo() + createFoo(X) function
  pairs to somthing like a direct
   QList<struct { X; std::function<X()>; }> fooCreators()
  to avoid e.g. the baseId.withSuffix() <-> id.suffixAfter(base)
  pingpong

- Remove the *Factories from the global object pool

- Do something about priority(). Falling back to plain
  qmake in android+qmake setup is not helpful.

Change-Id: I2be7d88d554c5aa8b7db8edf5b93278e1ae0112a
Reviewed-by: Tobias Hunger's avatarTobias Hunger <tobias.hunger@qt.io>
parent 9d3c5c6f
......@@ -95,7 +95,7 @@ private:
this);
};
AndroidBuildApkStep::AndroidBuildApkStep(ProjectExplorer::BuildStepList *parent, const Core::Id id)
AndroidBuildApkStep::AndroidBuildApkStep(ProjectExplorer::BuildStepList *parent, Core::Id id)
: ProjectExplorer::AbstractProcessStep(parent, id),
m_buildTargetSdk(AndroidConfig::apiLevelNameFor(AndroidConfigurations::
sdkManager()->latestAndroidSdkPlatform()))
......@@ -104,18 +104,6 @@ AndroidBuildApkStep::AndroidBuildApkStep(ProjectExplorer::BuildStepList *parent,
setDefaultDisplayName(tr("Build Android APK"));
}
AndroidBuildApkStep::AndroidBuildApkStep(ProjectExplorer::BuildStepList *parent,
AndroidBuildApkStep *other)
: ProjectExplorer::AbstractProcessStep(parent, other),
m_signPackage(other->signPackage()),
m_verbose(other->m_verbose),
m_useMinistro(other->useMinistro()),
m_openPackageLocation(other->m_openPackageLocation),
// leave m_openPackageLocationForRun at false
m_buildTargetSdk(other->m_buildTargetSdk)
{
}
bool AndroidBuildApkStep::init(QList<const BuildStep *> &earlierSteps)
{
ProjectExplorer::BuildConfiguration *bc = buildConfiguration();
......
......@@ -38,9 +38,11 @@ namespace Android {
class ANDROID_EXPORT AndroidBuildApkStep : public ProjectExplorer::AbstractProcessStep
{
Q_OBJECT
public:
AndroidBuildApkStep(ProjectExplorer::BuildStepList *bc, const Core::Id id);
protected:
AndroidBuildApkStep(ProjectExplorer::BuildStepList *bc, Core::Id id);
public:
bool fromMap(const QVariantMap &map) override;
QVariantMap toMap() const override;
......@@ -75,9 +77,6 @@ public:
protected:
Q_INVOKABLE void showInGraphicalShell();
AndroidBuildApkStep(ProjectExplorer::BuildStepList *bc,
AndroidBuildApkStep *other);
bool init(QList<const BuildStep *> &earlierSteps) override;
ProjectExplorer::BuildStepConfigWidget *createConfigWidget() override;
bool immutable() const override { return true; }
......
......@@ -24,6 +24,7 @@
****************************************************************************/
#include "androiddeployconfiguration.h"
#include "androidconstants.h"
#include "androiddeployqtstep.h"
#include "androidmanager.h"
......@@ -46,92 +47,40 @@ namespace Internal {
// Qt 5.2 has a new form of deployment
const char ANDROID_DEPLOYCONFIGURATION_ID[] = "Qt4ProjectManager.AndroidDeployConfiguration2";
AndroidDeployConfiguration::AndroidDeployConfiguration(Target *parent, Core::Id id)
: DeployConfiguration(parent, id)
{
setDisplayName(tr("Deploy to Android device"));
setDefaultDisplayName(displayName());
}
AndroidDeployConfiguration::AndroidDeployConfiguration(Target *parent, DeployConfiguration *source)
: DeployConfiguration(parent, source)
{
cloneSteps(source);
}
AndroidDeployConfigurationFactory::AndroidDeployConfigurationFactory(QObject *parent)
: DeployConfigurationFactory(parent)
{
setObjectName(QLatin1String("AndroidDeployConfigurationFactory"));
}
bool AndroidDeployConfigurationFactory::canCreate(Target *parent, Core::Id id) const
{
return availableCreationIds(parent).contains(id);
}
DeployConfiguration *AndroidDeployConfigurationFactory::create(Target *parent, Core::Id id)
{
AndroidDeployConfiguration *dc = new AndroidDeployConfiguration(parent, id);
dc->stepList()->insertStep(0, new AndroidDeployQtStep(dc->stepList()));
return dc;
}
bool AndroidDeployConfigurationFactory::canRestore(Target *parent, const QVariantMap &map) const
{
return canCreate(parent, idFromMap(map));
}
DeployConfiguration *AndroidDeployConfigurationFactory::restore(Target *parent, const QVariantMap &map)
{
if (!canRestore(parent, map))
return 0;
AndroidDeployConfiguration *dc = new AndroidDeployConfiguration(parent, idFromMap(map));
if (dc->fromMap(map))
return dc;
AndroidDeployConfiguration::AndroidDeployConfiguration(Target *parent)
: DeployConfiguration(parent, ANDROID_DEPLOYCONFIGURATION_ID)
{}
delete dc;
return 0;
}
bool AndroidDeployConfigurationFactory::canClone(Target *parent, DeployConfiguration *source) const
void AndroidDeployConfiguration::initialize()
{
if (!AndroidManager::supportsAndroid(parent))
return false;
return canCreate(parent, source->id());
stepList()->insertStep(0, new AndroidDeployQtStep(stepList()));
}
DeployConfiguration *AndroidDeployConfigurationFactory::clone(Target *parent, DeployConfiguration *source)
AndroidDeployConfigurationFactory::AndroidDeployConfigurationFactory()
{
if (!canClone(parent, source))
return 0;
return new AndroidDeployConfiguration(parent, source);
setObjectName("AndroidDeployConfigurationFactory");
registerDeployConfiguration<AndroidDeployConfiguration>(ANDROID_DEPLOYCONFIGURATION_ID);
setSupportedTargetDeviceTypes({Constants::ANDROID_DEVICE_TYPE});
setDefaultDisplayName(AndroidDeployConfiguration::tr("Deploy to Android device"));
}
QList<Core::Id> AndroidDeployConfigurationFactory::availableCreationIds(Target *parent) const
QList<QString> AndroidDeployConfigurationFactory::availableBuildTargets(Target *parent) const
{
QList<Core::Id> ids;
if (!parent->project()->supportsKit(parent->kit()))
return ids;
ToolChain *tc = ToolChainKitInformation::toolChain(parent->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
if (!tc || tc->targetAbi().osFlavor() != Abi::AndroidLinuxFlavor)
return ids;
return {};
QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(parent->kit());
if (!qt || qt->type() != QLatin1String(Constants::ANDROIDQT))
return ids;
ids << Core::Id(ANDROID_DEPLOYCONFIGURATION_ID);
return ids;
if (!qt || qt->type() != Constants::ANDROIDQT)
return {};
return {QString()};
}
QString AndroidDeployConfigurationFactory::displayNameForId(Core::Id id) const
bool AndroidDeployConfigurationFactory::canHandle(Target *parent) const
{
if (id == Core::Id(ANDROID_DEPLOYCONFIGURATION_ID))
return tr("Deploy on Android");
return QString();
return DeployConfigurationFactory::canHandle(parent)
&& AndroidManager::supportsAndroid(parent->kit());
}
} // namespace Internal
......
......@@ -33,14 +33,10 @@ namespace Internal {
class AndroidDeployConfiguration : public ProjectExplorer::DeployConfiguration
{
Q_OBJECT
friend class AndroidDeployConfigurationFactory;
public:
AndroidDeployConfiguration(ProjectExplorer::Target *parent, Core::Id id);
protected:
AndroidDeployConfiguration(ProjectExplorer::Target *parent, ProjectExplorer::DeployConfiguration *source);
explicit AndroidDeployConfiguration(ProjectExplorer::Target *parent);
void initialize() override;
};
class AndroidDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
......@@ -48,18 +44,10 @@ class AndroidDeployConfigurationFactory : public ProjectExplorer::DeployConfigur
Q_OBJECT
public:
explicit AndroidDeployConfigurationFactory(QObject *parent = 0);
bool canCreate(ProjectExplorer::Target *parent, Core::Id id) const override;
ProjectExplorer::DeployConfiguration *create(ProjectExplorer::Target *parent, Core::Id id) override;
bool canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const override;
ProjectExplorer::DeployConfiguration *restore(ProjectExplorer::Target *parent, const QVariantMap &map) override;
bool canClone(ProjectExplorer::Target *parent, ProjectExplorer::DeployConfiguration *source) const override;
ProjectExplorer::DeployConfiguration *clone(ProjectExplorer::Target *parent, ProjectExplorer::DeployConfiguration *source) override;
AndroidDeployConfigurationFactory();
QList<Core::Id> availableCreationIds(ProjectExplorer::Target *parent) const override;
// used to translate the ids to names to display to the user
QString displayNameForId(Core::Id id) const override;
bool canHandle(ProjectExplorer::Target *target) const override;
QList<QString> availableBuildTargets(ProjectExplorer::Target *parent) const override;
};
} // namespace Internal
......
......@@ -68,55 +68,28 @@ const QLatin1String InstallFailedPermissionModelDowngrade("INSTALL_FAILED_PERMIS
const QLatin1String InstallFailedVersionDowngrade("INSTALL_FAILED_VERSION_DOWNGRADE");
const Core::Id AndroidDeployQtStep::Id("Qt4ProjectManager.AndroidDeployQtStep");
//////////////////
// AndroidDeployQtStepFactory
/////////////////
AndroidDeployQtStepFactory::AndroidDeployQtStepFactory(QObject *parent)
: IBuildStepFactory(parent)
{
}
// AndroidDeployQtStepFactory
QList<BuildStepInfo> AndroidDeployQtStepFactory::availableSteps(BuildStepList *parent) const
AndroidDeployQtStepFactory::AndroidDeployQtStepFactory()
{
if (parent->id() != ProjectExplorer::Constants::BUILDSTEPS_DEPLOY
|| !AndroidManager::supportsAndroid(parent->target())
|| parent->contains(AndroidDeployQtStep::Id))
return {};
return {{AndroidDeployQtStep::Id, tr("Deploy to Android device or emulator")}};
registerStep<AndroidDeployQtStep>(AndroidDeployQtStep::Id);
setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_DEPLOY);
setRepeatable(false);
setDisplayName(tr("Deploy to Android device or emulator"));
}
ProjectExplorer::BuildStep *AndroidDeployQtStepFactory::create(ProjectExplorer::BuildStepList *parent, Core::Id id)
bool AndroidDeployQtStepFactory::canHandle(BuildStepList *parent) const
{
Q_UNUSED(id);
return new AndroidDeployQtStep(parent);
return BuildStepFactory::canHandle(parent)
&& AndroidManager::supportsAndroid(parent->target());
}
ProjectExplorer::BuildStep *AndroidDeployQtStepFactory::clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *product)
{
return new AndroidDeployQtStep(parent, static_cast<AndroidDeployQtStep *>(product));
}
//////////////////
// AndroidDeployQtStep
/////////////////
AndroidDeployQtStep::AndroidDeployQtStep(ProjectExplorer::BuildStepList *parent)
: ProjectExplorer::BuildStep(parent, Id)
{
ctor();
}
AndroidDeployQtStep::AndroidDeployQtStep(ProjectExplorer::BuildStepList *parent,
AndroidDeployQtStep *other)
: ProjectExplorer::BuildStep(parent, other)
{
ctor();
}
void AndroidDeployQtStep::ctor()
{
m_uninstallPreviousPackage = QtSupport::QtKitInformation::qtVersion(target()->kit())->qtVersion() < QtSupport::QtVersionNumber(5, 4, 0);
m_uninstallPreviousPackageRun = false;
......
......@@ -41,18 +41,12 @@ QT_END_NAMESPACE
namespace Android {
namespace Internal {
class AndroidDeployQtStepFactory : public ProjectExplorer::IBuildStepFactory
class AndroidDeployQtStepFactory : public ProjectExplorer::BuildStepFactory
{
Q_OBJECT
public:
explicit AndroidDeployQtStepFactory(QObject *parent = 0);
QList<ProjectExplorer::BuildStepInfo>
availableSteps(ProjectExplorer::BuildStepList *parent) const override;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent,
ProjectExplorer::BuildStep *product) override;
AndroidDeployQtStepFactory();
bool canHandle(ProjectExplorer::BuildStepList *bsl) const;
};
class AndroidDeployQtStep : public ProjectExplorer::BuildStep
......@@ -95,8 +89,6 @@ signals:
void setSerialNumber(const QString &serialNumber);
private:
AndroidDeployQtStep(ProjectExplorer::BuildStepList *bc, AndroidDeployQtStep *other);
void ctor();
void runCommand(const QString &program, const QStringList &arguments);
bool init(QList<const BuildStep *> &earlierSteps) override;
......
......@@ -45,8 +45,8 @@ const char amStartArgsKey[] = "Android.AmStartArgsKey";
const char preStartShellCmdsKey[] = "Android.PreStartShellCmdListKey";
const char postFinishShellCmdsKey[] = "Android.PostFinishShellCmdListKey";
AndroidRunConfiguration::AndroidRunConfiguration(Target *target)
: RunConfiguration(target)
AndroidRunConfiguration::AndroidRunConfiguration(Target *target, Core::Id id)
: RunConfiguration(target, id)
{
}
......@@ -87,10 +87,12 @@ Utils::OutputFormatter *AndroidRunConfiguration::createOutputFormatter() const
bool AndroidRunConfiguration::fromMap(const QVariantMap &map)
{
if (!RunConfiguration::fromMap(map))
return false;
m_preStartShellCommands = map.value(preStartShellCmdsKey).toStringList();
m_postFinishShellCommands = map.value(postFinishShellCmdsKey).toStringList();
m_amStartExtraArgs = map.value(amStartArgsKey).toStringList();
return RunConfiguration::fromMap(map);
return true;
}
QVariantMap AndroidRunConfiguration::toMap() const
......
......@@ -35,7 +35,7 @@ class ANDROID_EXPORT AndroidRunConfiguration : public ProjectExplorer::RunConfig
{
Q_OBJECT
public:
explicit AndroidRunConfiguration(ProjectExplorer::Target *target);
explicit AndroidRunConfiguration(ProjectExplorer::Target *target, Core::Id id);
QWidget *createConfigurationWidget() override;
Utils::OutputFormatter *createOutputFormatter() const override;
......
......@@ -47,9 +47,8 @@ class TestRunConfiguration : public ProjectExplorer::RunConfiguration
public:
TestRunConfiguration(ProjectExplorer::Target *parent, TestConfiguration *config)
: ProjectExplorer::RunConfiguration(parent)
: ProjectExplorer::RunConfiguration(parent, "AutoTest.TestRunConfig")
{
initialize("AutoTest.TestRunConfig");
setDefaultDisplayName(tr("AutoTest Debug"));
bool enableQuick = false;
......
......@@ -50,53 +50,21 @@ using namespace ProjectExplorer;
const char AUTOGEN_ADDITIONAL_ARGUMENTS_KEY[] = "AutotoolsProjectManager.AutogenStep.AdditionalArguments";
const char AUTOGEN_STEP_ID[] = "AutotoolsProjectManager.AutogenStep";
/////////////////////////////
// AutogenStepFactory class
/////////////////////////////
AutogenStepFactory::AutogenStepFactory(QObject *parent) : IBuildStepFactory(parent)
{ }
QList<BuildStepInfo> AutogenStepFactory::availableSteps(BuildStepList *parent) const
{
if (parent->target()->project()->id() != Constants::AUTOTOOLS_PROJECT_ID
|| parent->id() != ProjectExplorer::Constants::BUILDSTEPS_BUILD)
return {};
QString display = tr("Autogen", "Display name for AutotoolsProjectManager::AutogenStep id.");
return {{AUTOGEN_STEP_ID, display}};
}
// AutogenStepFactory
BuildStep *AutogenStepFactory::create(BuildStepList *parent, Core::Id id)
AutogenStepFactory::AutogenStepFactory()
{
Q_UNUSED(id)
return new AutogenStep(parent);
registerStep<AutogenStep>(AUTOGEN_STEP_ID);
setDisplayName(tr("Autogen", "Display name for AutotoolsProjectManager::AutogenStep id."));
setSupportedProjectType(Constants::AUTOTOOLS_PROJECT_ID);
setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
}
BuildStep *AutogenStepFactory::clone(BuildStepList *parent, BuildStep *source)
{
return new AutogenStep(parent, static_cast<AutogenStep *>(source));
}
////////////////////////
// AutogenStep class
////////////////////////
AutogenStep::AutogenStep(BuildStepList *bsl) : AbstractProcessStep(bsl, Core::Id(AUTOGEN_STEP_ID))
{
ctor();
}
AutogenStep::AutogenStep(BuildStepList *bsl, Core::Id id) : AbstractProcessStep(bsl, id)
{
ctor();
}
AutogenStep::AutogenStep(BuildStepList *bsl, AutogenStep *bs) : AbstractProcessStep(bsl, bs),
m_additionalArguments(bs->additionalArguments())
{
ctor();
}
// AutogenStep
void AutogenStep::ctor()
AutogenStep::AutogenStep(BuildStepList *bsl) : AbstractProcessStep(bsl, AUTOGEN_STEP_ID)
{
setDefaultDisplayName(tr("Autogen"));
}
......
......@@ -48,18 +48,12 @@ class AutogenStepConfigWidget;
*
* This factory is used to create instances of AutogenStep.
*/
class AutogenStepFactory : public ProjectExplorer::IBuildStepFactory
class AutogenStepFactory : public ProjectExplorer::BuildStepFactory
{
Q_OBJECT
public:
AutogenStepFactory(QObject *parent = 0);
QList<ProjectExplorer::BuildStepInfo>
availableSteps(ProjectExplorer::BuildStepList *parent) const override;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *source) override;
AutogenStepFactory();
};
///////////////////////
......@@ -97,14 +91,8 @@ public:
signals:
void additionalArgumentsChanged(const QString &);
protected:
AutogenStep(ProjectExplorer::BuildStepList *bsl, AutogenStep *bs);
AutogenStep(ProjectExplorer::BuildStepList *bsl, Core::Id id);
bool fromMap(const QVariantMap &map) override;
private:
void ctor();
bool fromMap(const QVariantMap &map) override;
QString m_additionalArguments;
bool m_runAutogen = false;
......
......@@ -49,55 +49,21 @@ using namespace ProjectExplorer;
const char AUTORECONF_STEP_ID[] = "AutotoolsProjectManager.AutoreconfStep";
const char AUTORECONF_ADDITIONAL_ARGUMENTS_KEY[] = "AutotoolsProjectManager.AutoreconfStep.AdditionalArguments";
////////////////////////////////
// AutoreconfStepFactory class
////////////////////////////////
AutoreconfStepFactory::AutoreconfStepFactory(QObject *parent) : IBuildStepFactory(parent)
{ }
QList<BuildStepInfo> AutoreconfStepFactory::availableSteps(BuildStepList *parent) const
{
if (parent->target()->project()->id() != Constants::AUTOTOOLS_PROJECT_ID
|| parent->id() != ProjectExplorer::Constants::BUILDSTEPS_BUILD)
return {};
QString display = tr("Autoreconf", "Display name for AutotoolsProjectManager::AutoreconfStep id.");
return {{AUTORECONF_STEP_ID, display}};
}
// AutoreconfStepFactory class
BuildStep *AutoreconfStepFactory::create(BuildStepList *parent, Core::Id id)
AutoreconfStepFactory::AutoreconfStepFactory()
{
Q_UNUSED(id);
return new AutoreconfStep(parent);
registerStep<AutoreconfStep>(AUTORECONF_STEP_ID);
setDisplayName(tr("Autoreconf", "Display name for AutotoolsProjectManager::AutoreconfStep id."));
setSupportedProjectType(Constants::AUTOTOOLS_PROJECT_ID);
setSupportedStepList(ProjectExplorer::Constants::BUILDSTEPS_BUILD);
}
BuildStep *AutoreconfStepFactory::clone(BuildStepList *parent, BuildStep *source)
{
return new AutoreconfStep(parent, static_cast<AutoreconfStep *>(source));
}
/////////////////////////
// AutoreconfStep class
/////////////////////////
AutoreconfStep::AutoreconfStep(BuildStepList *bsl) :
AbstractProcessStep(bsl, Core::Id(AUTORECONF_STEP_ID))
{
ctor();
}
AutoreconfStep::AutoreconfStep(BuildStepList *bsl, Core::Id id) : AbstractProcessStep(bsl, id)
{
ctor();
}
AutoreconfStep::AutoreconfStep(BuildStepList *bsl, AutoreconfStep *bs) :
AbstractProcessStep(bsl, bs),
m_additionalArguments(bs->additionalArguments())
{
ctor();
}
void AutoreconfStep::ctor()
AutoreconfStep::AutoreconfStep(BuildStepList *bsl) : AbstractProcessStep(bsl, AUTORECONF_STEP_ID)
{
setDefaultDisplayName(tr("Autoreconf"));
}
......
......@@ -47,18 +47,12 @@ class AutoreconfStep;
*
* The factory is used to create instances of AutoreconfStep.
*/
class AutoreconfStepFactory : public ProjectExplorer::IBuildStepFactory
class AutoreconfStepFactory : public ProjectExplorer::BuildStepFactory
{
Q_OBJECT
public:
AutoreconfStepFactory(QObject *parent = 0);
QList<ProjectExplorer::BuildStepInfo>
availableSteps(ProjectExplorer::BuildStepList *parent) const override;
ProjectExplorer::BuildStep *create(ProjectExplorer::BuildStepList *parent, Core::Id id) override;
ProjectExplorer::BuildStep *clone(ProjectExplorer::BuildStepList *parent, ProjectExplorer::BuildStep *source) override;
AutoreconfStepFactory();
};