Stop special casing qbs.buildVariant in command line handling.

This introduces qbs.configurationName, which takes the place of
qbs.buildVariant in the command line and acts as a unique identifier
for each build configuration, rather than relying on the combination of
qbs.buildVariant and the profile name to do so.

No longer special casing qbs.buildVariant allows the variant to be
decoupled from the build configuration, and allow scenarios where a
project may contain products hardcoded for particular build variants,
and in future, special debug-and-release builds which create a single
framework product containing multiple build variants.

Incidentally, this change allows building multiple configurations of the
same build variant and profile name combination, since the build
configuration is no longer keyed on the aggregate of those values.
Building for different profiles with the same configuration name in
parallel is now no longer possible, but this is easily worked around by
simply specifying different configuration names for such combinations.

For example, the following is now possible:

 qbs \
   static profile:a qbs.buildVariant:release project.useStaticLibraries:true \
   dynamic profile:a qbs.buildVariant:release project.useStaticLibraries:false

[ChangeLog] Each build configuration now requires a unique name, which
is specified on the command line in the same place that qbs.buildVariant
used to be specified. This allows building for multiple configurations
with the same variant.

Change-Id: I96ab9fc96861ab7e6a04a7d291a093115c22010e
Reviewed-by: Christian Kandeler <christian.kandeler@theqtcompany.com>
Reviewed-by: Leena Miettinen <riitta-leena.miettinen@qt.io>
Reviewed-by: Jake Petroules <jake.petroules@qt.io>
Reviewed-by: Joerg Bornemann <joerg.bornemann@qt.io>

2 files changed, 32 insertions, 37 deletions

diff --git a/src/app/qbs/commandlinefrontend.cpp b/src/app/qbs/commandlinefrontend.cpp
index 35e059f6a..4c84ed77f 100644
--- a/src/app/qbs/commandlinefrontend.cpp
+++ b/src/app/qbs/commandlinefrontend.cpp
@@ -140,7 +140,7 @@ void CommandLineFrontend::start()
             params.setRestoreBehavior(SetupProjectParameters::RestoreOnly);
         foreach (const QVariantMap &buildConfig, m_parser.buildConfigurations()) {
             QVariantMap userConfig = buildConfig;
-            const QString buildVariantKey = QLatin1String("qbs.buildVariant");
+            const QString configurationKey = QLatin1String("qbs.configurationName");
             const QString profileKey = QLatin1String("qbs.profile");
             const QString installRootKey = QLatin1String("qbs.installRoot");
             QString installRoot = userConfig.value(installRootKey).toString();
@@ -148,7 +148,7 @@ void CommandLineFrontend::start()
                 installRoot.prepend(QLatin1Char('/')).prepend(QDir::currentPath());
                 userConfig.insert(installRootKey, installRoot);
             }
-            const QString buildVariant = userConfig.take(buildVariantKey).toString();
+            const QString configurationName = userConfig.take(configurationKey).toString();
             QString profileName = userConfig.take(profileKey).toString();
             if (profileName.isEmpty())
                 profileName = m_settings->defaultProfile();
@@ -166,7 +166,7 @@ void CommandLineFrontend::start()
             params.setLibexecPath(QDir::cleanPath(QCoreApplication::applicationDirPath()
                     + QLatin1String("/" QBS_RELATIVE_LIBEXEC_PATH)));
             params.setTopLevelProfile(profileName);
-            params.setBuildVariant(buildVariant);
+            params.setConfigurationName(configurationName);
             params.setBuildRoot(buildDirectory(profileName));
             params.setOverriddenValues(userConfig);
             SetupProjectJob * const job = Project().setupProject(params,
diff --git a/src/app/qbs/parser/commandlineparser.cpp b/src/app/qbs/parser/commandlineparser.cpp
index d97ac1c00..addaffaef 100644
--- a/src/app/qbs/parser/commandlineparser.cpp
+++ b/src/app/qbs/parser/commandlineparser.cpp
@@ -76,7 +76,7 @@ public:
     void setupLogLevel();
     void setupBuildOptions();
     bool checkForExistingBuildConfiguration(const QList<QVariantMap> &buildConfigs,
-                                            const QString &buildVariant, const QString &profile);
+                                            const QString &configurationName);
     bool isSameProfile(const QString &profile1, const QString &profile2) const;
     bool withNonDefaultProducts() const;
     bool dryRun() const;
@@ -272,49 +272,47 @@ QString CommandLineParser::commandDescription() const
     return d->command->longDescription();
 }
 
-static QString getBuildVariant(const QVariantMap &buildConfig)
+static QString getBuildConfigurationName(const QVariantMap &buildConfig)
 {
-    return buildConfig.value(QLatin1String("qbs.buildVariant")).toString();
-}
-
-static QString getProfile(const QVariantMap &buildConfig)
-{
-    return buildConfig.value(QLatin1String("qbs.profile")).toString();
+    return buildConfig.value(QLatin1String("qbs.configurationName")).toString();
 }
 
 QList<QVariantMap> CommandLineParser::buildConfigurations() const
 {
-    // first: build variant, second: properties. Empty variant name used for global properties.
+    // first: configuration name, second: properties.
+    // Empty configuration name used for global properties.
     typedef QPair<QString, QVariantMap> PropertyListItem;
-    QList<PropertyListItem> propertiesPerBuildVariant;
+    QList<PropertyListItem> propertiesPerConfiguration;
 
-    const QString buildVariantKey = QLatin1String("qbs.buildVariant");
-    QString currentBuildVariant;
+    const QString configurationNameKey = QLatin1String("qbs.configurationName");
+    QString currentConfigurationName;
     QVariantMap currentProperties;
     foreach (const QString &arg, d->command->additionalArguments()) {
         const int sepPos = arg.indexOf(QLatin1Char(':'));
-        if (sepPos == -1) { // New build variant found.
-            propertiesPerBuildVariant << qMakePair(currentBuildVariant, currentProperties);
-            currentBuildVariant = arg;
+        if (sepPos == -1) { // New build configuration found.
+            propertiesPerConfiguration << qMakePair(currentConfigurationName, currentProperties);
+            currentConfigurationName = arg;
             currentProperties.clear();
             continue;
         }
         const QString property = d->propertyName(arg.left(sepPos));
-        if (property.isEmpty())
+        if (property.isEmpty()) {
             qbsWarning() << Tr::tr("Ignoring empty property.");
-        else if (property == buildVariantKey)
-            qbsWarning() << Tr::tr("Refusing to overwrite special property '%1'.").arg(buildVariantKey);
-        else
+        } else if (property == configurationNameKey) {
+            qbsWarning() << Tr::tr("Refusing to overwrite special property '%1'.")
+                            .arg(configurationNameKey);
+        } else {
             currentProperties.insert(property, arg.mid(sepPos + 1));
+        }
     }
-    propertiesPerBuildVariant << qMakePair(currentBuildVariant, currentProperties);
+    propertiesPerConfiguration << qMakePair(currentConfigurationName, currentProperties);
 
-    if (propertiesPerBuildVariant.count() == 1) // No build variant specified on command line.
-        propertiesPerBuildVariant << PropertyListItem(QLatin1String("debug"), QVariantMap());
+    if (propertiesPerConfiguration.count() == 1) // No configuration name specified on command line.
+        propertiesPerConfiguration << PropertyListItem(QStringLiteral("default"), QVariantMap());
 
-    const QVariantMap globalProperties = propertiesPerBuildVariant.takeFirst().second;
+    const QVariantMap globalProperties = propertiesPerConfiguration.takeFirst().second;
     QList<QVariantMap> buildConfigs;
-    foreach (const PropertyListItem &item, propertiesPerBuildVariant) {
+    foreach (const PropertyListItem &item, propertiesPerConfiguration) {
         QVariantMap properties = item.second;
         for (QVariantMap::ConstIterator globalPropIt = globalProperties.constBegin();
                  globalPropIt != globalProperties.constEnd(); ++globalPropIt) {
@@ -322,15 +320,14 @@ QList<QVariantMap> CommandLineParser::buildConfigurations() const
                 properties.insert(globalPropIt.key(), globalPropIt.value());
         }
 
-        const QString buildVariant = item.first;
-        const QString profile = getProfile(properties);
-        if (d->checkForExistingBuildConfiguration(buildConfigs, buildVariant, profile)) {
-            qbsWarning() << Tr::tr("Ignoring redundant request to build for variant '%1' and "
-                                   "profile '%2'.").arg(buildVariant, profile);
+        const QString configurationName = item.first;
+        if (d->checkForExistingBuildConfiguration(buildConfigs, configurationName)) {
+            qbsWarning() << Tr::tr("Ignoring redundant request to build for configuration '%1'.")
+                            .arg(configurationName);
             continue;
         }
 
-        properties.insert(buildVariantKey, buildVariant);
+        properties.insert(configurationNameKey, configurationName);
         buildConfigs << properties;
     }
 
@@ -589,13 +586,11 @@ QString CommandLineParser::CommandLineParserPrivate::propertyName(const QString
 }
 
 bool CommandLineParser::CommandLineParserPrivate::checkForExistingBuildConfiguration(
-        const QList<QVariantMap> &buildConfigs, const QString &buildVariant, const QString &profile)
+        const QList<QVariantMap> &buildConfigs, const QString &configurationName)
 {
     foreach (const QVariantMap &buildConfig, buildConfigs) {
-        if (buildVariant == getBuildVariant(buildConfig)
-            && isSameProfile(profile, getProfile(buildConfig))) {
+        if (configurationName == getBuildConfigurationName(buildConfig))
             return true;
-        }
     }
     return false;
 }