Reduce setup information hardcoded into toolchain probes.

This moves a step closer to making profiles as thin as possible.

Change-Id: I35fa165c2fa50e9830a460521ba0e3c2c97284c6
Reviewed-by: Christian Kandeler <christian.kandeler@theqtcompany.com>

7 files changed, 59 insertions, 89 deletions

diff --git a/share/qbs/modules/Android/ndk/ndk.qbs b/share/qbs/modules/Android/ndk/ndk.qbs
index e8cf26ae3..2c70b1f54 100644
--- a/share/qbs/modules/Android/ndk/ndk.qbs
+++ b/share/qbs/modules/Android/ndk/ndk.qbs
@@ -69,7 +69,7 @@ Module {
     }
 
     property string hostArch: ndkProbe.hostArch
-    property string toolchainDirPrefix: NdkUtils.toolchainDirPrefix(qbs.toolchain, abi)
+    property string toolchainDir: NdkUtils.toolchainDir(qbs.toolchain, toolchainVersion, abi)
     property bool enableExceptions: appStl !== "system"
     property bool enableRtti: appStl !== "system"
     property bool hardFloat
@@ -142,25 +142,13 @@ Module {
         allowedValues: ["arm", "thumb"]
     }
 
-    cpp.toolchainInstallPath: FileInfo.joinPaths(ndkDir, "toolchains",
-                                                 toolchainDirPrefix +
-                                                 NdkUtils.toolchainVersionNumber(toolchainVersion),
-                                                 "prebuilt", hostArch, "bin")
+    cpp.toolchainInstallPath: FileInfo.joinPaths(ndkDir, "toolchains", toolchainDir, "prebuilt",
+                                                 hostArch, "bin")
 
     cpp.toolchainPrefix: NdkUtils.toolchainPrefix(qbs.toolchain, abi)
 
-    qbs.toolchain: {
-        var tc = [];
-        if (toolchainVersion && toolchainVersion.startsWith("clang"))
-            tc.push("clang");
-        return tc.concat(["gcc"]);
-    }
-
     qbs.optimization: ["armeabi", "armeabi-v7a"].contains(abi) ? "small" : base
 
-    cpp.compilerName: qbs.toolchain.contains("clang") ? "clang++" : "g++"
-    cpp.linkerName: qbs.toolchain.contains("clang") ? "clang++" : "g++"
-
     cpp.commonCompilerFlags: NdkUtils.commonCompilerFlags(qbs.buildVariant, abi, hardFloat, armMode)
 
     cpp.linkerFlags: NdkUtils.commonLinkerFlags(abi, hardFloat)
diff --git a/share/qbs/modules/Android/ndk/utils.js b/share/qbs/modules/Android/ndk/utils.js
index a293b1ae0..42d4d9cc5 100644
--- a/share/qbs/modules/Android/ndk/utils.js
+++ b/share/qbs/modules/Android/ndk/utils.js
@@ -48,19 +48,12 @@ function androidAbi(arch) {
     }[arch];
 }
 
-function toolchainVersionNumber(version) {
-    var prefix = "clang";
-    if (version && version.startsWith(prefix))
-        return version.substr(prefix.length);
-    return version;
-}
-
-function toolchainDirPrefix(toolchain, abi) {
+function toolchainDir(toolchain, version, abi) {
     if (toolchain && toolchain.contains("clang"))
-        return "llvm-";
+        return "llvm-" + version;
     if (["x86", "x86_64"].contains(abi))
-        return abi + "-";
-    return toolchainPrefix(toolchain, abi);
+        return abi + "-" + version;
+    return toolchainPrefix(toolchain, abi) + version;
 }
 
 function toolchainPrefix(toolchain, abi) {
diff --git a/share/qbs/modules/cpp/GenericGCC.qbs b/share/qbs/modules/cpp/GenericGCC.qbs
index 9766a7b68..042e537e2 100644
--- a/share/qbs/modules/cpp/GenericGCC.qbs
+++ b/share/qbs/modules/cpp/GenericGCC.qbs
@@ -50,8 +50,8 @@ CppModule {
     property stringList transitiveSOs
     property string toolchainPrefix
     property path toolchainInstallPath
-    compilerName: 'g++'
-    linkerName: 'g++'
+    compilerName: cxxCompilerName
+    linkerName: cxxCompilerName
     property string archiverName: 'ar'
     property string nmName: 'nm'
     property string objcopyName: "objcopy"
@@ -83,6 +83,22 @@ CppModule {
         return path
     }
 
+    property string cCompilerName: executablePrefix
+                                   + (qbs.toolchain.contains("clang") ? "clang" : "gcc")
+                                   + executableSuffix
+    property string cxxCompilerName: executablePrefix
+                                     + (qbs.toolchain.contains("clang") ? "clang++" : "g++")
+                                     + executableSuffix
+
+    compilerPathByLanguage: {
+        return {
+            "c": toolchainPathPrefix + cCompilerName,
+            "cpp": toolchainPathPrefix + cxxCompilerName,
+            "objc": toolchainPathPrefix + cCompilerName,
+            "objcpp": toolchainPathPrefix + cxxCompilerName
+        };
+    }
+
     compilerPath: toolchainPathPrefix + compilerName
     linkerPath: toolchainPathPrefix + linkerName
     property path archiverPath: { return toolchainPathPrefix + archiverName }
diff --git a/share/qbs/modules/cpp/windows-msvc.qbs b/share/qbs/modules/cpp/windows-msvc.qbs
index b5a8dbf18..ff919f1f5 100644
--- a/share/qbs/modules/cpp/windows-msvc.qbs
+++ b/share/qbs/modules/cpp/windows-msvc.qbs
@@ -45,6 +45,12 @@ CppModule {
 
     windowsApiCharacterSet: "unicode"
     platformDefines: base.concat(WindowsUtils.characterSetDefines(windowsApiCharacterSet))
+    platformCommonCompilerFlags: {
+        var flags = base;
+        if (compilerVersionMajor >= 18) // 2013
+            flags.push("/FS");
+        return flags;
+    }
     compilerDefines: ['_WIN32']
     warningLevel: "default"
     compilerName: "cl.exe"
diff --git a/src/app/qbs-setup-android/android-setup.cpp b/src/app/qbs-setup-android/android-setup.cpp
index 60b6d4aaa..b6765606b 100644
--- a/src/app/qbs-setup-android/android-setup.cpp
+++ b/src/app/qbs-setup-android/android-setup.cpp
@@ -159,6 +159,7 @@ void setupNdk(qbs::Settings *settings, const QString &profileName, const QString
     Profile mainProfile(profileName, settings);
     mainProfile.setValue(qls("Android.ndk.ndkDir"), QDir::cleanPath(ndkDirPath));
     mainProfile.setValue(qls("Android.sdk.ndkDir"), QDir::cleanPath(ndkDirPath));
+    mainProfile.setValue(qls("qbs.toolchain"), QStringList() << qls("gcc"));
     foreach (const QString &arch, expectedArchs()) {
         Profile p(subProfileName(profileName, arch), settings);
         p.removeProfile();
diff --git a/src/app/qbs-setup-toolchains/msvcprobe.cpp b/src/app/qbs-setup-toolchains/msvcprobe.cpp
index 87c90bd01..a224329c8 100644
--- a/src/app/qbs-setup-toolchains/msvcprobe.cpp
+++ b/src/app/qbs-setup-toolchains/msvcprobe.cpp
@@ -72,11 +72,6 @@ static void addMSVCPlatform(const MSVC &msvc, Settings *settings, QList<Profile>
     p.setValue(QLatin1String("cpp.toolchainInstallPath"), installPath);
     p.setValue(QLatin1String("qbs.toolchain"), QStringList(QLatin1String("msvc")));
     p.setValue(QLatin1String("qbs.architecture"), canonicalArchitecture(architecture));
-    if (msvc.version.toInt() >= 2013) {
-        const QStringList flags(QLatin1String("/FS"));
-        p.setValue(QLatin1String("cpp.platformCFlags"), flags);
-        p.setValue(QLatin1String("cpp.platformCxxFlags"), flags);
-    }
     const QProcessEnvironment compilerEnvironment = msvc.environments.value(architecture);
     setCompilerVersion(installPath + QLatin1String("/cl.exe"), QStringList(QLatin1String("msvc")),
                        p, compilerEnvironment);
diff --git a/src/app/qbs-setup-toolchains/probe.cpp b/src/app/qbs-setup-toolchains/probe.cpp
index 531bbf0c1..68d63d229 100644
--- a/src/app/qbs-setup-toolchains/probe.cpp
+++ b/src/app/qbs-setup-toolchains/probe.cpp
@@ -120,50 +120,36 @@ static QString gccMachineName(const QString &compilerFilePath)
     return qsystem(compilerFilePath, QStringList() << QLatin1String("-dumpmachine")).trimmed();
 }
 
-static void setupCompilerPathByLanguage(Profile &profile, const QStringList &toolchainTypes,
-        const QString &toolchainInstallPath, const QString &toolchainPrefix)
+static QStringList standardCompilerFileNames()
 {
-    QVariantMap m;
-    if (toolchainTypes.contains(QLatin1String("clang"))) {
-        m[QLatin1String("c")] = m[QLatin1String("objc")] = QLatin1String("clang");
-        m[QLatin1String("cpp")] = m[QLatin1String("objcpp")] = QLatin1String("clang++");
-    } else if (toolchainTypes.contains(QLatin1String("gcc"))) {
-        m[QLatin1String("c")] = m[QLatin1String("objc")] = QLatin1String("gcc");
-        m[QLatin1String("cpp")] = m[QLatin1String("objcpp")] = QLatin1String("g++");
-    } else {
-        qDebug("WARNING: unexpected toolchain %s", qPrintable(toJSLiteral(toolchainTypes)));
-        return;
-    }
-
-    const QString toolchainPathPrefix = toolchainInstallPath + QLatin1Char('/') + toolchainPrefix;
-    for (QVariantMap::iterator it = m.begin(); it != m.end();) {
-        const QString filePath = HostOsInfo::appendExecutableSuffix(toolchainPathPrefix
-                                                                    + it.value().toString());
-        if (QFile::exists(filePath)) {
-            it.value() = filePath;
-            ++it;
-            continue;
-        }
-        qDebug("WARNING: Compiler %s for file tag %s not found.",
-               qPrintable(QDir::toNativeSeparators(filePath)), qPrintable(it.key()));
-        it = m.erase(it);
-    }
-    if (!m.isEmpty())
-        profile.setValue(QLatin1String("cpp.compilerPathByLanguage"), m);
+    return QStringList() << QStringLiteral("gcc") << QStringLiteral("g++")
+                         << QStringLiteral("clang") << QStringLiteral("clang++");
 }
 
 static void setCommonProperties(Profile &profile, const QString &compilerFilePath,
-        const QString &toolchainPrefix, const QStringList &toolchainTypes,
-        const QString &architecture)
+        const QStringList &toolchainTypes, const QString &architecture)
 {
-    QFileInfo cfi(compilerFilePath);
-    const QString toolchainInstallPath = cfi.absolutePath();
-    profile.setValue(QLatin1String("cpp.toolchainInstallPath"), toolchainInstallPath);
-    profile.setValue(QLatin1String("cpp.compilerName"), cfi.fileName());
+    const QFileInfo cfi(compilerFilePath);
+    const QString compilerName = QFileInfo(compilerFilePath).fileName();
+    if (!standardCompilerFileNames().contains(compilerName))
+        qWarning("%s", qPrintable(
+                     QString(QStringLiteral("'%1' is not a standard compiler file name; "
+                                            "you must set the cpp.cCompilerName and "
+                                            "cpp.cxxCompilerName properties of this profile "
+                                            "manually")).arg(compilerName)));
+
+
+    if (toolchainTypes.contains(QStringLiteral("mingw")))
+        profile.setValue(QStringLiteral("qbs.targetOS"), QStringList(QStringLiteral("windows")));
+
+    const QString prefix = compilerName.left(compilerName.lastIndexOf(QLatin1Char('-')) + 1);
+    if (!prefix.isEmpty())
+        profile.setValue(QLatin1String("cpp.toolchainPrefix"), prefix);
+
+    profile.setValue(QLatin1String("cpp.toolchainInstallPath"), cfi.absolutePath());
     profile.setValue(QLatin1String("qbs.toolchain"), toolchainTypes);
     profile.setValue(QLatin1String("qbs.architecture"), canonicalArchitecture(architecture));
     setCompilerVersion(compilerFilePath, toolchainTypes, profile);
-    setupCompilerPathByLanguage(profile, toolchainTypes, toolchainInstallPath, toolchainPrefix);
 }
 
 class ToolPathSetup
@@ -200,10 +186,8 @@ static Profile createGccProfile(const QString &compilerFilePath, Settings *setti
 {
     const QString machineName = gccMachineName(compilerFilePath);
     const QStringList compilerTriplet = machineName.split(QLatin1Char('-'));
-    const bool isMingw = toolchainTypes.contains(QLatin1String("mingw"));
-    const bool isClang = toolchainTypes.contains(QLatin1String("clang"));
 
-    if (isMingw) {
+    if (toolchainTypes.contains(QLatin1String("mingw"))) {
         if (!validMinGWMachines().contains(machineName)) {
             throw ErrorInfo(Tr::tr("Detected gcc platform '%1' is not supported.")
                     .arg(machineName));
@@ -215,27 +199,14 @@ static Profile createGccProfile(const QString &compilerFilePath, Settings *setti
 
     Profile profile(!profileName.isEmpty() ? profileName : machineName, settings);
     profile.removeProfile();
-    if (isMingw) {
-        profile.setValue(QLatin1String("qbs.targetOS"), QStringList(QLatin1String("windows")));
-    }
-
-    const QString compilerName = QFileInfo(compilerFilePath).fileName();
-    QString toolchainPrefix;
-    if (compilerName.contains(QLatin1Char('-'))) {
-        QStringList nameParts = compilerName.split(QLatin1Char('-'));
-        profile.setValue(QLatin1String("cpp.compilerName"), nameParts.takeLast());
-        toolchainPrefix = nameParts.join(QLatin1Char('-')) + QLatin1Char('-');
-        profile.setValue(QLatin1String("cpp.toolchainPrefix"), toolchainPrefix);
-    }
-    profile.setValue(QLatin1String("cpp.linkerName"),
-                     isClang ? QLatin1String("clang++") : QLatin1String("g++"));
-    setCommonProperties(profile, compilerFilePath, toolchainPrefix, toolchainTypes,
-                        compilerTriplet.first());
+    setCommonProperties(profile, compilerFilePath, toolchainTypes, compilerTriplet.first());
 
     // Check whether auxiliary tools reside within the toolchain's install path.
     // This might not be the case when using icecc or another compiler wrapper.
     const QString compilerDirPath = QFileInfo(compilerFilePath).absolutePath();
-    const ToolPathSetup toolPathSetup(&profile, compilerDirPath, toolchainPrefix);
+    const ToolPathSetup toolPathSetup(&profile, compilerDirPath,
+                                      profile.value(QStringLiteral("cpp.toolchainPrefix"))
+                                      .toString());
     toolPathSetup.apply(QLatin1String("ar"), QLatin1String("cpp.archiverPath"));
     toolPathSetup.apply(QLatin1String("nm"), QLatin1String("cpp.nmPath"));
     if (HostOsInfo::isOsxHost())