diff --git a/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp b/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
index c4a0089b84d..00302f6d350 100644
--- a/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
@@ -53,22 +53,6 @@ namespace {
 
 Q_LOGGING_CATEGORY(cmInputLog, "qtc.cmake.import", QtWarningMsg);
 
-struct CMakeToolChainData
-{
-    QByteArray languageId;
-    Utils::FilePath compilerPath;
-    Core::Id mapLanguageIdToQtC() const
-    {
-        const QByteArray li = languageId.toLower();
-        if (li == "cxx")
-            return ProjectExplorer::Constants::CXX_LANGUAGE_ID;
-        else if (li == "c")
-            return ProjectExplorer::Constants::C_LANGUAGE_ID;
-        else
-            return Core::Id::fromName(languageId);
-    }
-};
-
 struct DirectoryData
 {
     // Project Stuff:
@@ -83,7 +67,7 @@ struct DirectoryData
     QByteArray toolset;
     QByteArray sysroot;
     QtProjectImporter::QtVersionData qt;
-    QVector<CMakeToolChainData> toolChains;
+    QVector<ToolChainDescription> toolChains;
 };
 
 static QStringList scanDirectory(const QString &path, const QString &prefix)
@@ -218,14 +202,21 @@ static Utils::FilePath qmakeFromCMakeCache(const CMakeConfig &config)
     return Utils::FilePath();
 }
 
-QVector<CMakeToolChainData> extractToolChainsFromCache(const CMakeConfig &config)
+static QVector<ToolChainDescription> extractToolChainsFromCache(const CMakeConfig &config)
 {
-    QVector<CMakeToolChainData> result;
+    QVector<ToolChainDescription> result;
     for (const CMakeConfigItem &i : config) {
         if (!i.key.startsWith("CMAKE_") || !i.key.endsWith("_COMPILER"))
             continue;
         const QByteArray language = i.key.mid(6, i.key.count() - 6 - 9); // skip "CMAKE_" and "_COMPILER"
-        result.append({language, Utils::FilePath::fromUtf8(i.value)});
+        Core::Id languageId;
+        if (language == "CXX")
+            languageId = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
+        else  if (language == "C")
+            languageId = ProjectExplorer::Constants::C_LANGUAGE_ID;
+        else
+            languageId = Core::Id::fromName(language);
+        result.append({Utils::FilePath::fromUtf8(i.value), languageId});
     }
     return result;
 }
@@ -300,8 +291,8 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
     if (data->qt.qt && QtSupport::QtKitAspect::qtVersionId(k) != data->qt.qt->uniqueId())
         return false;
 
-    for (const CMakeToolChainData &tcd : data->toolChains) {
-        ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.mapLanguageIdToQtC());
+    for (const ToolChainDescription &tcd : data->toolChains) {
+        ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
         if (!tc || tc->compilerCommand() != tcd.compilerPath)
             return false;
     }
@@ -328,9 +319,8 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
 
         SysRootKitAspect::setSysRoot(k, Utils::FilePath::fromUtf8(data->sysroot));
 
-        for (const CMakeToolChainData &cmtcd : data->toolChains) {
-            const ToolChainData tcd
-                    = findOrCreateToolChains(cmtcd.compilerPath, cmtcd.mapLanguageIdToQtC());
+        for (const ToolChainDescription &cmtcd : data->toolChains) {
+            const ToolChainData tcd = findOrCreateToolChains(cmtcd);
             QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
 
             if (tcd.areTemporary) {
@@ -464,17 +454,17 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
             << QStringList("CMAKE_SOMETHING_ELSE=/tmp") << QByteArrayList() << QStringList();
     QTest::newRow("CXX compiler")
             << QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++"})
-            << QByteArrayList({"CXX"})
+            << QByteArrayList({"Cxx"})
             << QStringList({"/usr/bin/g++"});
     QTest::newRow("CXX compiler, C compiler")
             << QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++", "CMAKE_C_COMPILER=/usr/bin/clang"})
-            << QByteArrayList({"CXX", "C"})
+            << QByteArrayList({"Cxx", "C"})
             << QStringList({"/usr/bin/g++", "/usr/bin/clang"});
     QTest::newRow("CXX compiler, C compiler, strange compiler")
             << QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++",
                              "CMAKE_C_COMPILER=/usr/bin/clang",
                              "CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler"})
-            << QByteArrayList({"CXX", "C", "STRANGE_LANGUAGE"})
+            << QByteArrayList({"Cxx", "C", "STRANGE_LANGUAGE"})
             << QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
     QTest::newRow("CXX compiler, C compiler, strange compiler (with junk)")
             << QStringList({"FOO=test",
@@ -484,7 +474,7 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
                              "SOMETHING_COMPILER=/usr/bin/something",
                              "CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler",
                              "BAR=more test"})
-            << QByteArrayList({"CXX", "C", "STRANGE_LANGUAGE"})
+            << QByteArrayList({"Cxx", "C", "STRANGE_LANGUAGE"})
             << QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
 }
 
@@ -505,10 +495,10 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
         config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
     }
 
-    QVector<CMakeToolChainData> tcs = extractToolChainsFromCache(config);
+    const QVector<ToolChainDescription> tcs = extractToolChainsFromCache(config);
     QCOMPARE(tcs.count(), expectedLanguages.count());
     for (int i = 0; i < tcs.count(); ++i) {
-        QCOMPARE(tcs.at(i).languageId, expectedLanguages.at(i));
+        QCOMPARE(tcs.at(i).language, expectedLanguages.at(i));
         QCOMPARE(tcs.at(i).compilerPath.toString(), expectedToolChains.at(i));
     }
 }
diff --git a/src/plugins/nim/project/nimtoolchainfactory.cpp b/src/plugins/nim/project/nimtoolchainfactory.cpp
index 69293f18af9..7467ab77898 100644
--- a/src/plugins/nim/project/nimtoolchainfactory.cpp
+++ b/src/plugins/nim/project/nimtoolchainfactory.cpp
@@ -73,13 +73,13 @@ QList<ToolChain *> NimToolChainFactory::autoDetect(const QList<ToolChain *> &alr
     return result;
 }
 
-QList<ToolChain *> NimToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
+QList<ToolChain *> NimToolChainFactory::detectForImport(const ToolChainDescription &tcd)
 {
     QList<ToolChain *> result;
-    if (language == Constants::C_NIMLANGUAGE_ID) {
+    if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
         auto tc = new NimToolChain;
         tc->setDetection(ToolChain::ManualDetection); // FIXME: sure?
-        tc->setCompilerCommand(compilerPath);
+        tc->setCompilerCommand(tcd.compilerPath);
         result.append(tc);
     }
     return result;
diff --git a/src/plugins/nim/project/nimtoolchainfactory.h b/src/plugins/nim/project/nimtoolchainfactory.h
index af5a7a90c06..0b79653400b 100644
--- a/src/plugins/nim/project/nimtoolchainfactory.h
+++ b/src/plugins/nim/project/nimtoolchainfactory.h
@@ -42,7 +42,7 @@ public:
     NimToolChainFactory();
 
     QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &alreadyKnown) final;
-    QList<ProjectExplorer::ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
+    QList<ProjectExplorer::ToolChain *> detectForImport(const ProjectExplorer::ToolChainDescription &tcd) final;
 };
 
 class NimToolChainConfigWidget : public ProjectExplorer::ToolChainConfigWidget
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index fadedc3a927..097597b69ef 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -880,14 +880,14 @@ QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alr
     return tcs;
 }
 
-QList<ToolChain *> GccToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
+QList<ToolChain *> GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
 {
-    const QString fileName = compilerPath.fileName();
-    if ((language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
+    const QString fileName = tcd.compilerPath.toString();
+    if ((tcd.language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
                                                   || fileName.endsWith("gcc")))
-            || (language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
+            || (tcd.language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
                                                            || fileName.endsWith("g++"))))
-        return autoDetectToolChain(compilerPath, language, [](const ToolChain *tc) {
+        return autoDetectToolChain(tcd, [](const ToolChain *tc) {
             return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor;
         });
     return QList<ToolChain *>();
@@ -973,7 +973,7 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
             }
         }
         if (!alreadyExists) {
-            const QList<ToolChain *> newToolchains = autoDetectToolChain(compilerPath, language,
+            const QList<ToolChain *> newToolchains = autoDetectToolChain({compilerPath, language},
                                                                          checker);
             result << newToolchains;
             existingCandidates << newToolchains;
@@ -983,17 +983,16 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
     return result;
 }
 
-QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const FilePath &compilerPath,
-                                                            const Core::Id language,
+QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
                                                             const ToolchainChecker &checker)
 {
     QList<ToolChain *> result;
 
     Environment systemEnvironment = Environment::systemEnvironment();
-    GccToolChain::addCommandPathToEnvironment(compilerPath, systemEnvironment);
-    const FilePath localCompilerPath = findLocalCompiler(compilerPath, systemEnvironment);
+    GccToolChain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment);
+    const FilePath localCompilerPath = findLocalCompiler(tcd.compilerPath, systemEnvironment);
     Macros macros
-            = gccPredefinedMacros(localCompilerPath, gccPredefinedMacrosOptions(language),
+            = gccPredefinedMacros(localCompilerPath, gccPredefinedMacrosOptions(tcd.language),
                                   systemEnvironment.toStringList());
     const GccToolChain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath,
                                                                       systemEnvironment.toStringList(),
@@ -1003,13 +1002,13 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const FilePath &comp
         if (!tc)
             return result;
 
-        tc->setLanguage(language);
+        tc->setLanguage(tcd.language);
         tc->setDetection(ToolChain::AutoDetection);
         tc->predefinedMacrosCache()
             ->insert(QStringList(),
                      ToolChain::MacroInspectionReport{macros,
-                                                      ToolChain::languageVersion(language, macros)});
-        tc->setCompilerCommand(compilerPath);
+                                                      ToolChain::languageVersion(tcd.language, macros)});
+        tc->setCompilerCommand(tcd.compilerPath);
         tc->setSupportedAbis(detectedAbis.supportedAbis);
         tc->setTargetAbi(abi);
         tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple);
@@ -1455,13 +1454,13 @@ QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &a
     return tcs;
 }
 
-QList<ToolChain *> ClangToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
+QList<ToolChain *> ClangToolChainFactory::detectForImport(const ToolChainDescription &tcd)
 {
-    const QString fileName = compilerPath.fileName();
-    if ((language == Constants::C_LANGUAGE_ID && fileName.startsWith("clang") && !fileName.startsWith("clang++"))
-            || (language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("clang++")))
-        return autoDetectToolChain(compilerPath, language);
-    return QList<ToolChain *>();
+    const QString fileName = tcd.compilerPath.toString();
+    if ((tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("clang") && !fileName.startsWith("clang++"))
+            || (tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("clang++")))
+        return autoDetectToolChain(tcd);
+    return {};
 }
 
 ClangToolChainConfigWidget::ClangToolChainConfigWidget(ClangToolChain *tc) :
@@ -1637,17 +1636,18 @@ QList<ToolChain *> MingwToolChainFactory::autoDetect(const QList<ToolChain *> &a
     return result;
 }
 
-QList<ToolChain *> MingwToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
+QList<ToolChain *> MingwToolChainFactory::detectForImport(const ToolChainDescription &tcd)
 {
-    const QString fileName = compilerPath.fileName();
-    if ((language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
-                                                  || fileName.endsWith("gcc")))
-            || (language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
-                || fileName.endsWith("g++"))))
-        return autoDetectToolChain(compilerPath, language, [](const ToolChain *tc) {
+    const QString fileName = tcd.compilerPath.toString();
+    if ((tcd.language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
+                                                      || fileName.endsWith("gcc")))
+            || (tcd.language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
+                                                               || fileName.endsWith("g++"))))
+        return autoDetectToolChain(tcd, [](const ToolChain *tc) {
             return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
         });
-    return QList<ToolChain *>();
+
+    return {};
 }
 
 // --------------------------------------------------------------------------
@@ -1714,12 +1714,12 @@ QList<ToolChain *> LinuxIccToolChainFactory::autoDetect(const QList<ToolChain *>
     return result;
 }
 
-QList<ToolChain *> LinuxIccToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
+QList<ToolChain *> LinuxIccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
 {
-    const QString fileName = compilerPath.fileName();
-    if ((language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
-        (language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc")))
-        return autoDetectToolChain(compilerPath, language);
+    const QString fileName = tcd.compilerPath.toString();
+    if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
+        (tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc")))
+        return autoDetectToolChain(tcd);
     return {};
 }
 
diff --git a/src/plugins/projectexplorer/gcctoolchainfactories.h b/src/plugins/projectexplorer/gcctoolchainfactories.h
index 6d3a75ca3b8..c714a5ce163 100644
--- a/src/plugins/projectexplorer/gcctoolchainfactories.h
+++ b/src/plugins/projectexplorer/gcctoolchainfactories.h
@@ -55,7 +55,7 @@ public:
     GccToolChainFactory();
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
-    QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) override;
+    QList<ToolChain *> detectForImport(const ProjectExplorer::ToolChainDescription &tcd) override;
 
 protected:
     enum class DetectVariants { Yes, No };
@@ -65,7 +65,7 @@ protected:
             const Core::Id requiredTypeId, const QList<ToolChain *> &alreadyKnown,
             const ToolchainChecker &checker = {});
     QList<ToolChain *> autoDetectToolChain(
-            const Utils::FilePath &compilerPath, const Core::Id language,
+            const ToolChainDescription &tcd,
             const ToolchainChecker &checker = {});
 };
 
@@ -138,7 +138,7 @@ public:
     ClangToolChainFactory();
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
-    QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
+    QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
 };
 
 // --------------------------------------------------------------------------
@@ -153,7 +153,7 @@ public:
     MingwToolChainFactory();
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
-    QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
+    QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
 };
 
 // --------------------------------------------------------------------------
@@ -168,7 +168,7 @@ public:
     LinuxIccToolChainFactory();
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
-    QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
+    QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
 };
 
 } // namespace Internal
diff --git a/src/plugins/projectexplorer/projectimporter.cpp b/src/plugins/projectexplorer/projectimporter.cpp
index 4b5717f146d..1a2dbbfcad4 100644
--- a/src/plugins/projectexplorer/projectimporter.cpp
+++ b/src/plugins/projectexplorer/projectimporter.cpp
@@ -366,13 +366,12 @@ bool ProjectImporter::hasKitWithTemporaryData(Core::Id id, const QVariant &data)
     });
 }
 
-static ProjectImporter::ToolChainData
-createToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language)
+static ProjectImporter::ToolChainData createToolChains(const ToolChainDescription &tcd)
 {
     ProjectImporter::ToolChainData data;
 
     for (ToolChainFactory *factory : ToolChainFactory::allToolChainFactories()) {
-        data.tcs = factory->detectForImport(toolChainPath, language);
+        data.tcs = factory->detectForImport(tcd);
         if (data.tcs.isEmpty())
             continue;
 
@@ -387,12 +386,11 @@ createToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language)
 }
 
 ProjectImporter::ToolChainData
-ProjectImporter::findOrCreateToolChains(const Utils::FilePath &toolChainPath,
-                                        const Core::Id &language) const
+ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
 {
     ToolChainData result;
-    result.tcs = ToolChainManager::toolChains([toolChainPath, language](const ToolChain *tc) {
-        return tc->language() == language && tc->compilerCommand() == toolChainPath;
+    result.tcs = ToolChainManager::toolChains([&tcd](const ToolChain *tc) {
+        return tc->language() == tcd.language && tc->compilerCommand() == tcd.compilerPath;
     });
     for (const ToolChain *tc : result.tcs) {
         const QByteArray tcId = tc->id();
@@ -403,7 +401,7 @@ ProjectImporter::findOrCreateToolChains(const Utils::FilePath &toolChainPath,
 
     // Create a new toolchain:
     UpdateGuard guard(*this);
-    return createToolChains(toolChainPath, language);
+    return createToolChains(tcd);
 }
 
 } // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/projectimporter.h b/src/plugins/projectexplorer/projectimporter.h
index f1cf482607a..20a2700683c 100644
--- a/src/plugins/projectexplorer/projectimporter.h
+++ b/src/plugins/projectexplorer/projectimporter.h
@@ -27,12 +27,10 @@
 
 #include "projectexplorer_export.h"
 
-#include <coreplugin/id.h>
+#include "toolchain.h"
 
 #include <utils/fileutils.h>
 
-#include <QVariant>
-
 namespace ProjectExplorer {
 
 class BuildInfo;
@@ -110,7 +108,7 @@ protected:
     // Does *any* kit feature the requested data yet?
     bool hasKitWithTemporaryData(Core::Id id, const QVariant &data) const;
 
-    ToolChainData findOrCreateToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language) const;
+    ToolChainData findOrCreateToolChains(const ToolChainDescription &tcd) const;
 
 private:
     void markKitAsTemporary(Kit *k) const;
diff --git a/src/plugins/projectexplorer/toolchain.cpp b/src/plugins/projectexplorer/toolchain.cpp
index b76c2470501..2728df11c74 100644
--- a/src/plugins/projectexplorer/toolchain.cpp
+++ b/src/plugins/projectexplorer/toolchain.cpp
@@ -438,15 +438,14 @@ const QList<ToolChainFactory *> ToolChainFactory::allToolChainFactories()
 
 QList<ToolChain *> ToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
 {
-    Q_UNUSED(alreadyKnown);
-    return QList<ToolChain *>();
+    Q_UNUSED(alreadyKnown)
+    return {};
 }
 
-QList<ToolChain *> ToolChainFactory::detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language)
+QList<ToolChain *> ToolChainFactory::detectForImport(const ToolChainDescription &tcd)
 {
-    Q_UNUSED(compilerPath);
-    Q_UNUSED(language);
-    return QList<ToolChain *>();
+    Q_UNUSED(tcd)
+    return {};
 }
 
 bool ToolChainFactory::canCreate() const
diff --git a/src/plugins/projectexplorer/toolchain.h b/src/plugins/projectexplorer/toolchain.h
index 512c77fe16e..dce528bc027 100644
--- a/src/plugins/projectexplorer/toolchain.h
+++ b/src/plugins/projectexplorer/toolchain.h
@@ -72,6 +72,13 @@ class Kit;
 
 namespace Internal { class ToolChainSettingsAccessor; }
 
+class PROJECTEXPLORER_EXPORT ToolChainDescription
+{
+public:
+    Utils::FilePath compilerPath;
+    Core::Id language;
+};
+
 // --------------------------------------------------------------------------
 // ToolChain (documentation inside)
 // --------------------------------------------------------------------------
@@ -199,7 +206,7 @@ public:
     Core::Id supportedToolChainType() const;
 
     virtual QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown);
-    virtual QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language);
+    virtual QList<ToolChain *> detectForImport(const ToolChainDescription &tcd);
 
     virtual bool canCreate() const;
     virtual ToolChain *create();
diff --git a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp b/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
index d71554668a4..dd8600095d3 100644
--- a/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
+++ b/src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
@@ -208,9 +208,9 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
     return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
         QList<ToolChainData> tcData;
         if (!bgData->cxxCompilerPath.isEmpty())
-            tcData << findOrCreateToolChains(bgData->cxxCompilerPath, Constants::CXX_LANGUAGE_ID);
+            tcData << findOrCreateToolChains({bgData->cxxCompilerPath, Constants::CXX_LANGUAGE_ID});
         if (!bgData->cCompilerPath.isEmpty())
-            tcData << findOrCreateToolChains(bgData->cCompilerPath, Constants::C_LANGUAGE_ID);
+            tcData << findOrCreateToolChains({bgData->cCompilerPath, Constants::C_LANGUAGE_ID});
         foreach (const ToolChainData &tc, tcData) {
             if (!tc.tcs.isEmpty())
                 ToolChainKitAspect::setToolChain(k, tc.tcs.first());