QmakeProject: Use QString mkspec in QmakeKitInformation

... and BaseQtVersion, and QmakeBuildConfiguration.

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

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp

@@ -424,16 +424,17 @@ QmakeBuildConfiguration::MakefileState QmakeBuildConfiguration::compareToImportF
     // This copies the settings from userArgs to actualArgs (minus some we
     // are not interested in), splitting them up into individual strings:
     extractSpecFromArguments(&userArgs, workingDirectory, version, &actualArgs);
-    FileName actualSpec = qs->mkspec();
+    const QString actualSpec = qs->mkspec();
 
     QString qmakeArgs = parse.unparsedArguments();
     QStringList parsedArgs;
-    FileName parsedSpec = extractSpecFromArguments(&qmakeArgs, workingDirectory, version, &parsedArgs);
+    QString parsedSpec =
+            extractSpecFromArguments(&qmakeArgs, workingDirectory, version, &parsedArgs);
 
     qCDebug(logs) << "  Actual args:" << actualArgs;
     qCDebug(logs) << "  Parsed args:" << parsedArgs;
-    qCDebug(logs) << "  Actual spec:" << actualSpec.toString();
+    qCDebug(logs) << "  Actual spec:" << actualSpec;
-    qCDebug(logs) << "  Parsed spec:" << parsedSpec.toString();
+    qCDebug(logs) << "  Parsed spec:" << parsedSpec;
     qCDebug(logs) << "  Actual config:" << qs->deducedArguments();
     qCDebug(logs) << "  Parsed config:" << parse.config();
 
@@ -474,8 +475,8 @@ QmakeBuildConfiguration::MakefileState QmakeBuildConfiguration::compareToImportF
     }
     // Actual spec is the default one
 //                    qDebug() << "AS vs VS" << actualSpec << version->mkspec();
-    if ((actualSpec == version->mkspec() || actualSpec == FileName::fromLatin1("default"))
+    if ((actualSpec == version->mkspec() || actualSpec == "default")
-            && (parsedSpec == version->mkspec() || parsedSpec == FileName::fromLatin1("default") || parsedSpec.isEmpty())) {
+            && (parsedSpec == version->mkspec() || parsedSpec == "default" || parsedSpec.isEmpty())) {
         qCDebug(logs) << "**Matched specs (2)";
         return MakefileMatches;
     }
@@ -486,7 +487,7 @@ QmakeBuildConfiguration::MakefileState QmakeBuildConfiguration::compareToImportF
     return MakefileIncompatible;
 }
 
-FileName QmakeBuildConfiguration::extractSpecFromArguments(QString *args,
+QString QmakeBuildConfiguration::extractSpecFromArguments(QString *args,
                                                          const QString &directory, const BaseQtVersion *version,
                                                          QStringList *outArgs)
 {
@@ -520,7 +521,7 @@ FileName QmakeBuildConfiguration::extractSpecFromArguments(QString *args,
     }
 
     if (parsedSpec.isEmpty())
-        return FileName();
+        return {};
 
     FileName baseMkspecDir = FileName::fromUserInput(
             version->qmakeProperty("QT_HOST_DATA") + QLatin1String("/mkspecs"));
@@ -552,7 +553,7 @@ FileName QmakeBuildConfiguration::extractSpecFromArguments(QString *args,
         if (parsedSpec.isChildOf(sourceMkSpecPath))
             parsedSpec = parsedSpec.relativeChildPath(sourceMkSpecPath);
     }
-    return parsedSpec;
+    return parsedSpec.toString();
 }
 
 bool QmakeBuildConfiguration::isEnabled() const
@@ -724,7 +725,7 @@ QmakeBuildConfiguration::LastKitState::LastKitState() = default;
 QmakeBuildConfiguration::LastKitState::LastKitState(Kit *k)
     : m_qtVersion(QtKitAspect::qtVersionId(k)),
       m_sysroot(SysRootKitAspect::sysRoot(k).toString()),
-      m_mkspec(QmakeKitAspect::mkspec(k).toString())
+      m_mkspec(QmakeKitAspect::mkspec(k))
 {
     ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     m_toolchain = tc ? tc->id() : QByteArray();

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.h

@@ -83,7 +83,7 @@ public:
 
     enum MakefileState { MakefileMatches, MakefileForWrongProject, MakefileIncompatible, MakefileMissing };
     MakefileState compareToImportFrom(const QString &makefile, QString *errorString = nullptr);
-    static Utils::FileName extractSpecFromArguments(
+    static QString extractSpecFromArguments(
             QString *arguments, const QString &directory, const QtSupport::BaseQtVersion *version,
             QStringList *outArgs = nullptr);
 

src/plugins/qmakeprojectmanager/qmakekitinformation.cpp

@@ -36,6 +36,7 @@
 #include <utils/algorithm.h>
 #include <utils/qtcassert.h>
 
+#include <QDir>
 #include <QLineEdit>
 
 using namespace ProjectExplorer;
@@ -66,14 +67,13 @@ private:
     void refresh() override
     {
         if (!m_ignoreChange)
-            m_lineEdit->setText(QmakeKitAspect::mkspec(m_kit).toUserOutput());
+            m_lineEdit->setText(QDir::toNativeSeparators(QmakeKitAspect::mkspec(m_kit)));
     }
 
     void mkspecWasChanged(const QString &text)
     {
         m_ignoreChange = true;
-        QmakeKitAspect::setMkspec(m_kit, Utils::FileName::fromString(text),
+        QmakeKitAspect::setMkspec(m_kit, text, QmakeKitAspect::MkspecSource::User);
-                                  QmakeKitAspect::MkspecSource::User);
         m_ignoreChange = false;
     }
 
@@ -97,7 +97,7 @@ Tasks QmakeKitAspect::validate(const Kit *k) const
     Tasks result;
     QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(k);
 
-    FileName mkspec = QmakeKitAspect::mkspec(k);
+    const QString mkspec = QmakeKitAspect::mkspec(k);
     if (!version && !mkspec.isEmpty())
         result << Task(Task::Warning, tr("No Qt version set, so mkspec is ignored."),
                        FileName(), -1, ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM);
@@ -117,13 +117,13 @@ void QmakeKitAspect::setup(Kit *k)
     if (version->type() == "Boot2Qt.QtVersionType" || version->type() == "Qdb.EmbeddedLinuxQt")
         return;
 
-    FileName spec = QmakeKitAspect::mkspec(k);
+    QString spec = QmakeKitAspect::mkspec(k);
     if (spec.isEmpty())
         spec = version->mkspec();
 
     ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
-    if (!tc || (!tc->suggestedMkspecList().empty() && !tc->suggestedMkspecList().contains(spec.toString()))) {
+    if (!tc || (!tc->suggestedMkspecList().empty() && !tc->suggestedMkspecList().contains(spec))) {
         const QList<ToolChain *> possibleTcs = ToolChainManager::toolChains(
                     [version](const ToolChain *t) {
             return t->isValid()
@@ -133,7 +133,7 @@ void QmakeKitAspect::setup(Kit *k)
         if (!possibleTcs.isEmpty()) {
             const QList<ToolChain *> goodTcs = Utils::filtered(possibleTcs,
                                                                [&spec](const ToolChain *t) {
-                return t->suggestedMkspecList().contains(spec.toString());
+                return t->suggestedMkspecList().contains(spec);
             });
             // Hack to prefer a tool chain from PATH (e.g. autodetected) over other matches.
             // This improves the situation a bit if a cross-compilation tool chain has the
@@ -159,14 +159,14 @@ KitAspectWidget *QmakeKitAspect::createConfigWidget(Kit *k) const
 
 KitAspect::ItemList QmakeKitAspect::toUserOutput(const Kit *k) const
 {
-    return ItemList() << qMakePair(tr("mkspec"), mkspec(k).toUserOutput());
+    return {qMakePair(tr("mkspec"), QDir::toNativeSeparators(mkspec(k)))};
 }
 
 void QmakeKitAspect::addToMacroExpander(Kit *kit, MacroExpander *expander) const
 {
     expander->registerVariable("Qmake:mkspec", tr("Mkspec configured for qmake by the Kit."),
                 [kit]() -> QString {
-                    return QmakeKitAspect::mkspec(kit).toUserOutput();
+                    return QDir::toNativeSeparators(mkspec(kit));
                 });
 }
 
@@ -175,35 +175,35 @@ Core::Id QmakeKitAspect::id()
     return Constants::KIT_INFORMATION_ID;
 }
 
-FileName QmakeKitAspect::mkspec(const Kit *k)
+QString QmakeKitAspect::mkspec(const Kit *k)
 {
     if (!k)
-        return FileName();
+        return {};
-    return FileName::fromString(k->value(QmakeKitAspect::id()).toString());
+    return k->value(QmakeKitAspect::id()).toString();
 }
 
-FileName QmakeKitAspect::effectiveMkspec(const Kit *k)
+QString QmakeKitAspect::effectiveMkspec(const Kit *k)
 {
     if (!k)
-        return FileName();
+        return {};
-    FileName spec = mkspec(k);
+    const QString spec = mkspec(k);
     if (spec.isEmpty())
         return defaultMkspec(k);
     return spec;
 }
 
-void QmakeKitAspect::setMkspec(Kit *k, const FileName &fn, MkspecSource source)
+void QmakeKitAspect::setMkspec(Kit *k, const QString &mkspec, MkspecSource source)
 {
     QTC_ASSERT(k, return);
-    k->setValue(QmakeKitAspect::id(), source == MkspecSource::Code && fn == defaultMkspec(k)
+    k->setValue(QmakeKitAspect::id(), source == MkspecSource::Code && mkspec == defaultMkspec(k)
-                ? QString() : fn.toString());
+                ? QString() : mkspec);
 }
 
-FileName QmakeKitAspect::defaultMkspec(const Kit *k)
+QString QmakeKitAspect::defaultMkspec(const Kit *k)
 {
     QtSupport::BaseQtVersion *version = QtSupport::QtKitAspect::qtVersion(k);
     if (!version) // No version, so no qmake
-        return FileName();
+        return {};
 
     return version->mkspecFor(ToolChainKitAspect::toolChain(k,
                         ProjectExplorer::Constants::CXX_LANGUAGE_ID));

src/plugins/qmakeprojectmanager/qmakekitinformation.h

@@ -48,10 +48,10 @@ public:
 
     static Core::Id id();
     enum class MkspecSource { User, Code };
-    static void setMkspec(ProjectExplorer::Kit *k, const Utils::FileName &fn, MkspecSource source);
+    static void setMkspec(ProjectExplorer::Kit *k, const QString &mkspec, MkspecSource source);
-    static Utils::FileName mkspec(const ProjectExplorer::Kit *k);
+    static QString mkspec(const ProjectExplorer::Kit *k);
-    static Utils::FileName effectiveMkspec(const ProjectExplorer::Kit *k);
+    static QString effectiveMkspec(const ProjectExplorer::Kit *k);
-    static Utils::FileName defaultMkspec(const ProjectExplorer::Kit *k);
+    static QString defaultMkspec(const ProjectExplorer::Kit *k);
 };
 
 } // namespace Internal

src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp

@@ -67,7 +67,7 @@ struct DirectoryData
     Utils::FileName buildDirectory;
     Utils::FileName canonicalQmakeBinary;
     QtProjectImporter::QtVersionData qtVersionData;
-    FileName parsedSpec;
+    QString parsedSpec;
     BaseQtVersion::QmakeBuildConfigs buildConfig;
     QString additionalArguments;
     QMakeStepConfig config;
@@ -185,8 +185,8 @@ QList<void *> QmakeProjectImporter::examineDirectory(const FileName &importPath)
         qCDebug(logs) << "  Extracted spec:" << data->parsedSpec;
         qCDebug(logs) << "  Arguments now:" << data->additionalArguments;
 
-        FileName versionSpec = version->mkspec();
+        const QString versionSpec = version->mkspec();
-        if (data->parsedSpec.isEmpty() || data->parsedSpec == FileName::fromLatin1("default")) {
+        if (data->parsedSpec.isEmpty() || data->parsedSpec == "default") {
             data->parsedSpec = versionSpec;
             qCDebug(logs) << "  No parsed spec or default spec => parsed spec now:" << data->parsedSpec;
         }
@@ -204,7 +204,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
     const QLoggingCategory &logs = MakeFileParse::logging();
 
     BaseQtVersion *kitVersion = QtKitAspect::qtVersion(k);
-    FileName kitSpec = QmakeKitAspect::mkspec(k);
+    QString kitSpec = QmakeKitAspect::mkspec(k);
     ToolChain *tc = ToolChainKitAspect::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (kitSpec.isEmpty() && kitVersion)
         kitSpec = kitVersion->mkspecFor(tc);
@@ -265,16 +265,16 @@ void QmakeProjectImporter::deleteDirectoryData(void *directoryData) const
     delete static_cast<DirectoryData *>(directoryData);
 }
 
-static const QList<ToolChain *> preferredToolChains(BaseQtVersion *qtVersion, const FileName &ms,
+static const QList<ToolChain *> preferredToolChains(BaseQtVersion *qtVersion, const QString &ms,
                                                     const QMakeStepConfig::TargetArchConfig &archConfig)
 {
-    const FileName spec = ms.isEmpty() ? qtVersion->mkspec() : ms;
+    const QString spec = ms.isEmpty() ? qtVersion->mkspec() : ms;
 
     const QList<ToolChain *> toolchains = ToolChainManager::toolChains();
     const Abis qtAbis = qtVersion->qtAbis();
     const auto matcher = [&](const ToolChain *tc) {
         return qtAbis.contains(tc->targetAbi())
-            && tc->suggestedMkspecList().contains(spec.toString())
+            && tc->suggestedMkspecList().contains(spec)
             && QMakeStepConfig::targetArchFor(tc->targetAbi(), qtVersion) == archConfig;
     };
     ToolChain * const cxxToolchain = findOrDefault(toolchains, [matcher](const ToolChain *tc) {
@@ -292,7 +292,7 @@ static const QList<ToolChain *> preferredToolChains(BaseQtVersion *qtVersion, co
 }
 
 Kit *QmakeProjectImporter::createTemporaryKit(const QtProjectImporter::QtVersionData &data,
-                                              const FileName &parsedSpec,
+                                              const QString &parsedSpec,
                                               const QMakeStepConfig::TargetArchConfig &archConfig,
                                               const QMakeStepConfig::OsType &osType) const
 {

src/plugins/qmakeprojectmanager/qmakeprojectimporter.h

@@ -50,7 +50,7 @@ private:
     void deleteDirectoryData(void *directoryData) const final;
 
     ProjectExplorer::Kit *createTemporaryKit(const QtProjectImporter::QtVersionData &data,
-                                             const Utils::FileName &parsedSpec,
+                                             const QString &parsedSpec,
                                              const QmakeProjectManager::QMakeStepConfig::TargetArchConfig &archConfig,
                                              const QMakeStepConfig::OsType &osType) const;
 };

src/plugins/qmakeprojectmanager/qmakestep.cpp

@@ -115,9 +115,9 @@ QString QMakeStep::allArguments(const BaseQtVersion *v, ArgumentFlags flags) con
             }
         }
     }
-    FileName specArg = mkspec();
+    const QString specArg = mkspec();
     if (!userProvidedMkspec && !specArg.isEmpty())
-        arguments << "-spec" << specArg.toUserOutput();
+        arguments << "-spec" << QDir::toNativeSeparators(specArg);
 
     // Find out what flags we pass on to qmake
     arguments << bc->configCommandLineArguments();
@@ -491,14 +491,14 @@ QString QMakeStep::userArguments()
     return m_userArgs;
 }
 
-FileName QMakeStep::mkspec() const
+QString QMakeStep::mkspec() const
 {
     QString additionalArguments = m_userArgs;
     QtcProcess::addArgs(&additionalArguments, m_extraArgs);
     for (QtcProcess::ArgIterator ait(&additionalArguments); ait.next(); ) {
         if (ait.value() == "-spec") {
             if (ait.next())
-                return FileName::fromUserInput(ait.value());
+                return FileName::fromUserInput(ait.value()).toString();
         }
     }
 

src/plugins/qmakeprojectmanager/qmakestep.h

@@ -136,7 +136,7 @@ public:
     // QMake extra arguments. Not user editable.
     QStringList extraArguments() const;
     void setExtraArguments(const QStringList &args);
-    Utils::FileName mkspec() const;
+    QString mkspec() const;
     bool linkQmlDebuggingLibrary() const;
     void setLinkQmlDebuggingLibrary(bool enable);
     bool useQtQuickCompiler() const;

src/plugins/qtsupport/baseqtversion.cpp

@@ -718,7 +718,7 @@ QString BaseQtVersion::toHtml(bool verbose) const
         str << "<tr><td><b>" << QCoreApplication::translate("BaseQtVersion", "Source:")
             << "</b></td><td>" << sourcePath().toUserOutput() << "</td></tr>";
         str << "<tr><td><b>" << QCoreApplication::translate("BaseQtVersion", "mkspec:")
-            << "</b></td><td>" << mkspec().toUserOutput() << "</td></tr>";
+            << "</b></td><td>" << QDir::toNativeSeparators(mkspec()) << "</td></tr>";
         str << "<tr><td><b>" << QCoreApplication::translate("BaseQtVersion", "qmake:")
             << "</b></td><td>" << m_qmakeCommand.toUserOutput() << "</td></tr>";
         ensureMkSpecParsed();
@@ -965,24 +965,25 @@ void BaseQtVersion::parseMkSpec(ProFileEvaluator *evaluator) const
     m_mkspecValues.insert(ns, evaluator->value(ns));
 }
 
-FileName BaseQtVersion::mkspec() const
+QString BaseQtVersion::mkspec() const
 {
     updateMkspec();
-    return m_mkspec;
+    return m_mkspec.toString();
 }
 
-FileName BaseQtVersion::mkspecFor(ToolChain *tc) const
+QString BaseQtVersion::mkspecFor(ToolChain *tc) const
 {
-    FileName versionSpec = mkspec();
+    QString versionSpec = mkspec();
     if (!tc)
         return versionSpec;
 
     const QStringList tcSpecList = tc->suggestedMkspecList();
-    if (tcSpecList.contains(versionSpec.toString()))
+    if (tcSpecList.contains(versionSpec))
         return versionSpec;
+
     for (const QString &tcSpec : tcSpecList) {
-        if (hasMkspec(FileName::fromString(tcSpec)))
+        if (hasMkspec(tcSpec))
-            return FileName::fromString(tcSpec);
+            return tcSpec;
     }
 
     return versionSpec;
@@ -994,18 +995,18 @@ FileName BaseQtVersion::mkspecPath() const
     return m_mkspecFullPath;
 }
 
-bool BaseQtVersion::hasMkspec(const FileName &spec) const
+bool BaseQtVersion::hasMkspec(const QString &spec) const
 {
     if (spec.isEmpty())
         return true; // default spec of a Qt version
 
     QDir mkspecDir = QDir(QDir::fromNativeSeparators(qmakeProperty("QT_HOST_DATA"))
                           + "/mkspecs/");
-    const QString absSpec = mkspecDir.absoluteFilePath(spec.toString());
+    const QString absSpec = mkspecDir.absoluteFilePath(spec);
     if (QFileInfo(absSpec).isDir() && QFileInfo(absSpec + "/qmake.conf").isFile())
         return true;
     mkspecDir.setPath(sourcePath().toString() + "/mkspecs/");
-    const QString absSrcSpec = mkspecDir.absoluteFilePath(spec.toString());
+    const QString absSrcSpec = mkspecDir.absoluteFilePath(spec);
     return absSrcSpec != absSpec
             && QFileInfo(absSrcSpec).isDir()
             && QFileInfo(absSrcSpec + "/qmake.conf").isFile();
@@ -1218,7 +1219,7 @@ BaseQtVersion::createMacroExpander(const std::function<const BaseQtVersion *()>
         "Qt:Mkspec",
         QtKitAspect::tr("The mkspec of the current Qt version."),
         versionProperty([](const BaseQtVersion *version) {
-            return version->mkspec().toUserOutput();
+            return QDir::toNativeSeparators(version->mkspec());
         }));
 
     expander->registerVariable(

src/plugins/qtsupport/baseqtversion.h

@@ -178,13 +178,13 @@ public:
     Utils::FileName qmakeCommand() const;
 
     /// @returns the name of the mkspec
-    Utils::FileName mkspec() const;
+    QString mkspec() const;
-    Utils::FileName mkspecFor(ProjectExplorer::ToolChain *tc) const;
+    QString mkspecFor(ProjectExplorer::ToolChain *tc) const;
     /// @returns the full path to the default directory
     /// specifally not the directory the symlink/ORIGINAL_QMAKESPEC points to
     Utils::FileName mkspecPath() const;
 
-    bool hasMkspec(const Utils::FileName &spec) const;
+    bool hasMkspec(const QString &spec) const;
 
     enum QmakeBuildConfig
     {