Revert "ProjectExplorer: Remove ClangClToolChain::m_clangPath"

This reverts commit 7a2e49435c
as it broke handling clang-cl toolchains on Windows.

Fixes: QTCREATORBUG-25690
Fixes: QTCREATORBUG-25693
Fixes: QTCREATORBUG-25698
Change-Id: Idfc7bc86ad8dd97f645908d4fe9530c760085347
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/projectexplorer/msvctoolchain.cpp

@@ -1471,9 +1471,9 @@ void ClangClToolChainConfigWidget::setFromClangClToolChain()
 
     const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolChain());
     if (clangClToolChain->isAutoDetected())
-        m_llvmDirLabel->setText(clangClToolChain->compilerCommand().toUserOutput());
+        m_llvmDirLabel->setText(QDir::toNativeSeparators(clangClToolChain->clangPath()));
     else
-        m_compilerCommand->setFilePath(clangClToolChain->compilerCommand());
+        m_compilerCommand->setFilePath(Utils::FilePath::fromString(clangClToolChain->clangPath()));
 }
 
 static const MsvcToolChain *findMsvcToolChain(unsigned char wordWidth, Abi::OSFlavor flavor)
@@ -1571,7 +1571,7 @@ static QList<ToolChain *> detectClangClToolChainInPath(const QString &clangClPat
             res << tc;
         } else {
             auto cltc = new ClangClToolChain;
-            cltc->setCompilerCommand(FilePath::fromString(clangClPath));
+            cltc->setClangPath(clangClPath);
             cltc->setDisplayName(name);
             cltc->setDetection(ToolChain::AutoDetection);
             cltc->setLanguage(language);
@@ -1589,18 +1589,18 @@ static QString compilerFromPath(const QString &path)
 
 void ClangClToolChainConfigWidget::applyImpl()
 {
-    FilePath compilerCommand = m_compilerCommand->filePath();
+    Utils::FilePath clangClPath = m_compilerCommand->filePath();
     auto clangClToolChain = static_cast<ClangClToolChain *>(toolChain());
-    clangClToolChain->setCompilerCommand(compilerCommand);
+    clangClToolChain->setClangPath(clangClPath.toString());
 
-    if (compilerCommand.fileName() != "clang-cl.exe") {
+    if (clangClPath.fileName() != "clang-cl.exe") {
         clangClToolChain->resetVarsBat();
         setFromClangClToolChain();
         return;
     }
 
     const QString displayedVarsBat = m_varsBatDisplayCombo->currentText();
-    QList<ToolChain *> results = detectClangClToolChainInPath(compilerCommand.toString(),
+    QList<ToolChain *> results = detectClangClToolChainInPath(clangClPath.toString(),
                                                               {},
                                                               displayedVarsBat);
 
@@ -1640,22 +1640,26 @@ ClangClToolChain::ClangClToolChain()
 {
     setDisplayName("clang-cl");
     setTypeDisplayName(QCoreApplication::translate("ProjectExplorer::ClangToolChainFactory", "Clang"));
-    setCompilerCommandKey("ProjectExplorer.ClangClToolChain.LlvmDir");
 }
 
 bool ClangClToolChain::isValid() const
 {
-    return MsvcToolChain::isValid() && compilerCommand().exists()
+    const QFileInfo fi(clangPath());
-           && compilerCommand().fileName() == "clang-cl.exe";
+    return MsvcToolChain::isValid() && fi.exists() && fi.fileName() == "clang-cl.exe";
 }
 
 void ClangClToolChain::addToEnvironment(Utils::Environment &env) const
 {
     MsvcToolChain::addToEnvironment(env);
-    QDir path = compilerCommand().toFileInfo().absoluteDir(); // bin folder
+    QDir path = QFileInfo(m_clangPath).absoluteDir(); // bin folder
     env.prependOrSetPath(path.canonicalPath());
 }
 
+Utils::FilePath ClangClToolChain::compilerCommand() const
+{
+    return Utils::FilePath::fromString(m_clangPath);
+}
+
 QStringList ClangClToolChain::suggestedMkspecList() const
 {
     const QString mkspec = "win32-clang-" + Abi::toString(targetAbi().osFlavor());
@@ -1667,11 +1671,44 @@ QList<OutputLineParser *> ClangClToolChain::createOutputParsers() const
     return {new ClangClParser};
 }
 
+static inline QString llvmDirKey()
+{
+    return QStringLiteral("ProjectExplorer.ClangClToolChain.LlvmDir");
+}
+
+QVariantMap ClangClToolChain::toMap() const
+{
+    QVariantMap result = MsvcToolChain::toMap();
+    result.insert(llvmDirKey(), m_clangPath);
+    return result;
+}
+
+bool ClangClToolChain::fromMap(const QVariantMap &data)
+{
+    if (!MsvcToolChain::fromMap(data))
+        return false;
+    const QString clangPath = data.value(llvmDirKey()).toString();
+    if (clangPath.isEmpty())
+        return false;
+    m_clangPath = clangPath;
+
+    return true;
+}
+
 std::unique_ptr<ToolChainConfigWidget> ClangClToolChain::createConfigurationWidget()
 {
     return std::make_unique<ClangClToolChainConfigWidget>(this);
 }
 
+bool ClangClToolChain::operator==(const ToolChain &other) const
+{
+    if (!MsvcToolChain::operator==(other))
+        return false;
+
+    const auto *clangClTc = static_cast<const ClangClToolChain *>(&other);
+    return m_clangPath == clangClTc->m_clangPath;
+}
+
 Macros ClangClToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
                                               const Utils::Environment &env) const
 {
@@ -1685,7 +1722,7 @@ Macros ClangClToolChain::msvcPredefinedMacros(const QStringList &cxxflags,
     QStringList arguments = cxxflags;
     arguments.append(gccPredefinedMacrosOptions(language()));
     arguments.append("-");
-    Utils::SynchronousProcessResponse response = cpp.runBlocking({compilerCommand(), arguments});
+    Utils::SynchronousProcessResponse response = cpp.runBlocking({clangPath(), arguments});
     if (response.result != Utils::SynchronousProcessResponse::Finished || response.exitCode != 0) {
         // Show the warning but still parse the output.
         QTC_CHECK(false && "clang-cl exited with non-zero code.");

src/plugins/projectexplorer/msvctoolchain.h

@@ -164,18 +164,28 @@ public:
     bool isValid() const override;
     QStringList suggestedMkspecList() const override;
     void addToEnvironment(Utils::Environment &env) const override;
+    Utils::FilePath compilerCommand() const override; // FIXME: Remove
     QList<Utils::OutputLineParser *> createOutputParsers() const override;
+    QVariantMap toMap() const override;
+    bool fromMap(const QVariantMap &data) override;
     std::unique_ptr<ToolChainConfigWidget> createConfigurationWidget() override;
     BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
             const Utils::Environment &env) const override;
 
     const QList<MsvcToolChain *> &msvcToolchains() const;
+    QString clangPath() const { return m_clangPath; }
+    void setClangPath(const QString &path) { m_clangPath = path; }
 
     Macros msvcPredefinedMacros(const QStringList &cxxflags,
                                 const Utils::Environment &env) const override;
     Utils::LanguageVersion msvcLanguageVersion(const QStringList &cxxflags,
                                                const Utils::Id &language,
                                                const Macros &macros) const override;
+
+    bool operator==(const ToolChain &) const override;
+
+private:
+    QString m_clangPath;
 };
 
 // --------------------------------------------------------------------------

src/plugins/projectexplorer/toolchain.h

@@ -145,7 +145,7 @@ public:
 
     Utils::Id language() const;
 
-    Utils::FilePath compilerCommand() const;
+    virtual Utils::FilePath compilerCommand() const; // FIXME: De-virtualize.
     void setCompilerCommand(const Utils::FilePath &command);
 
     virtual QList<Utils::OutputLineParser *> createOutputParsers() const = 0;