Environment: Use Utils::FileName for path() and related methods

Update users accordingly.

Change-Id: I9432e82308e9d0630514c6c8632aeb6b6ee0cf90
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

src/libs/utils/buildablehelperlibrary.cpp

@@ -73,12 +73,12 @@ static bool isQmake(const QString &path)
 FileName BuildableHelperLibrary::findSystemQt(const Environment &env)
 {
     const QString qmake = QLatin1String("qmake");
-    QStringList paths = env.path();
+    FileNameList paths = env.path();
-    foreach (const QString &path, paths) {
+    foreach (const FileName &path, paths) {
         if (path.isEmpty())
             continue;
 
-        QDir dir(path);
+        QDir dir(path.toString());
 
         if (dir.exists(qmake)) {
             const QString qmakePath = dir.absoluteFilePath(qmake);

src/libs/utils/environment.cpp

@@ -362,21 +362,20 @@ void Environment::clear()
     m_values.clear();
 }
 
-FileName Environment::searchInDirectory(const QStringList &execs, QString directory,
+FileName Environment::searchInDirectory(const QStringList &execs, const FileName &directory,
-                                        QSet<QString> &alreadyChecked) const
+                                        QSet<FileName> &alreadyChecked) const
 {
-    const QChar slash = '/';
+    const int checkedCount = alreadyChecked.count();
-    // Avoid turing / into // on windows which triggers windows to check
+    alreadyChecked.insert(directory);
-    // for network drives!
-    const QString dir = directory.endsWith(slash) ? directory : directory + slash;
 
-    if (directory.isEmpty() || alreadyChecked.contains(dir))
+    if (directory.isEmpty() || alreadyChecked.count() == checkedCount)
-        return {};
+        return FileName();
 
-    alreadyChecked.insert(dir);
+    const QString dir = directory.toString();
 
+    QFileInfo fi;
     for (const QString &exec : execs) {
-        QFileInfo fi(dir + exec);
+        fi.setFile(dir, exec);
         if (fi.isFile() && fi.isExecutable())
             return FileName::fromString(fi.absoluteFilePath());
     }
@@ -406,7 +405,7 @@ bool Environment::isSameExecutable(const QString &exe1, const QString &exe2) con
     const QStringList exe2List = appendExeExtensions(exe2);
     for (const QString &i1 : exe1List) {
         for (const QString &i2 : exe2List) {
-            if (Utils::FileName::fromString(i1) == Utils::FileName::fromString(i2))
+            if (FileName::fromString(i1) == FileName::fromString(i2))
                 return true;
         }
     }
@@ -414,7 +413,7 @@ bool Environment::isSameExecutable(const QString &exe1, const QString &exe2) con
 }
 
 FileName Environment::searchInPath(const QString &executable,
-                                   const QStringList &additionalDirs,
+                                   const FileNameList &additionalDirs,
                                    const PathFilter &func) const
 {
     if (executable.isEmpty())
@@ -434,28 +433,29 @@ FileName Environment::searchInPath(const QString &executable,
         return FileName::fromString(exec);
     }
 
-    QSet<QString> alreadyChecked;
+    QSet<FileName> alreadyChecked;
-    for (const QString &dir : additionalDirs) {
+    for (const FileName &dir : additionalDirs) {
         FileName tmp = searchInDirectory(execs, dir, alreadyChecked);
-        if (!tmp.isEmpty() && (!func || func(tmp.toString())))
+        if (!tmp.isEmpty() && (!func || func(tmp)))
             return tmp;
     }
 
     if (executable.contains('/'))
         return FileName();
 
-    for (const QString &p : path()) {
+    for (const FileName &p : path()) {
-        FileName tmp = searchInDirectory(execs, QDir::fromNativeSeparators(p), alreadyChecked);
+        FileName tmp = searchInDirectory(execs, p, alreadyChecked);
-        if (!tmp.isEmpty() && (!func || func(tmp.toString())))
+        if (!tmp.isEmpty() && (!func || func(tmp)))
             return tmp;
     }
     return FileName();
 }
 
-QStringList Environment::path() const
+FileNameList Environment::path() const
 {
-    return value("PATH")
+    const QStringList pathComponents = value("PATH")
             .split(OsSpecificAspects(m_osType).pathListSeparator(), QString::SkipEmptyParts);
+    return Utils::transform(pathComponents, &FileName::fromUserInput);
 }
 
 QString Environment::value(const QString &key) const

src/libs/utils/environment.h

@@ -112,12 +112,12 @@ public:
     Environment::const_iterator constEnd() const;
     Environment::const_iterator constFind(const QString &name) const;
 
-    using PathFilter = std::function<bool(const QString &)>;
+    using PathFilter = std::function<bool(const FileName &)>;
     FileName searchInPath(const QString &executable,
-                          const QStringList &additionalDirs = QStringList(),
+                          const FileNameList &additionalDirs = FileNameList(),
                           const PathFilter &func = PathFilter()) const;
 
-    QStringList path() const;
+    FileNameList path() const;
     QStringList appendExeExtensions(const QString &executable) const;
 
     bool isSameExecutable(const QString &exe1, const QString &exe2) const;
@@ -129,8 +129,8 @@ public:
     bool operator==(const Environment &other) const;
 
 private:
-    FileName searchInDirectory(const QStringList &execs, QString directory,
+    FileName searchInDirectory(const QStringList &execs, const FileName &directory,
-                               QSet<QString> &alreadyChecked) const;
+                               QSet<FileName> &alreadyChecked) const;
     QMap<QString, QString> m_values;
     OsType m_osType;
 };

src/libs/utils/pathchooser.cpp

@@ -193,7 +193,7 @@ QString PathChooserPrivate::expandedPath(const QString &input) const
     switch (m_acceptingKind) {
     case PathChooser::Command:
     case PathChooser::ExistingCommand: {
-        const FileName expanded = m_environment.searchInPath(path, {m_baseDirectory});
+        const FileName expanded = m_environment.searchInPath(path, {FileName::fromString(m_baseDirectory)});
         return expanded.isEmpty() ? path : expanded.toString();
     }
     case PathChooser::Any:

src/plugins/android/androidtoolchain.cpp

@@ -116,9 +116,8 @@ void AndroidToolChain::addToEnvironment(Environment &env) const
         env.set(QLatin1String("JAVA_HOME"), javaHome.toString());
         Utils::FileName javaBin = javaHome;
         javaBin.appendPath(QLatin1String("bin"));
-        const QString jb = javaBin.toUserOutput();
+        if (!Utils::contains(env.path(), [&javaBin](const Utils::FileName &p) { return p == javaBin; }))
-        if (!Utils::contains(env.path(), [&jb](const QString &p) { return p == jb; }))
+            env.prependOrSetPath(javaBin.toUserOutput());
-            env.prependOrSetPath(jb);
     }
     env.set(QLatin1String("ANDROID_HOME"), AndroidConfigurations::currentConfig().sdkLocation().toString());
     env.set(QLatin1String("ANDROID_SDK_ROOT"), AndroidConfigurations::currentConfig().sdkLocation().toString());
@@ -209,16 +208,18 @@ FileNameList AndroidToolChain::suggestedMkspecList() const
 
 QString AndroidToolChain::makeCommand(const Environment &env) const
 {
-    QStringList extraDirectories = AndroidConfigurations::currentConfig().makeExtraSearchDirectories();
+    const Utils::FileNameList extraDirectories
+            = Utils::transform(AndroidConfigurations::currentConfig().makeExtraSearchDirectories(),
+                               [](const QString &s) { return Utils::FileName::fromString(s); });
     if (HostOsInfo::isWindowsHost()) {
-        FileName tmp = env.searchInPath(QLatin1String("ma-make.exe"), extraDirectories);
+        FileName tmp = env.searchInPath("ma-make.exe", extraDirectories);
         if (!tmp.isEmpty())
             return tmp.toString();
-        tmp = env.searchInPath(QLatin1String("mingw32-make"), extraDirectories);
+        tmp = env.searchInPath("mingw32-make", extraDirectories);
         return tmp.isEmpty() ? QLatin1String("mingw32-make") : tmp.toString();
     }
 
-    QString make = QLatin1String("make");
+    QString make = "make";
     FileName tmp = env.searchInPath(make, extraDirectories);
     return tmp.isEmpty() ? make : tmp.toString();
 }

src/plugins/cmakeprojectmanager/cmaketoolmanager.cpp

@@ -146,43 +146,38 @@ static void readAndDeleteLegacyCMakeSettings ()
 
 static QList<CMakeTool *> autoDetectCMakeTools()
 {
-    FileNameList suspects;
-
     Utils::Environment env = Environment::systemEnvironment();
 
-    QStringList path = env.path();
+    Utils::FileNameList path = env.path();
-    path.removeDuplicates();
+    path = Utils::filteredUnique(path);
 
     if (HostOsInfo::isWindowsHost()) {
         const QString progFiles = QLatin1String(qgetenv("ProgramFiles"));
-        path.append(progFiles + "/CMake");
+        path.append(Utils::FileName::fromString(progFiles + "/CMake"));
-        path.append(progFiles + "/CMake/bin");
+        path.append(Utils::FileName::fromString(progFiles + "/CMake/bin"));
         const QString progFilesX86 = QLatin1String(qgetenv("ProgramFiles(x86)"));
         if (!progFilesX86.isEmpty()) {
-            path.append(progFilesX86 + "/CMake");
+            path.append(Utils::FileName::fromString(progFilesX86 + "/CMake"));
-            path.append(progFilesX86 + "/CMake/bin");
+            path.append(Utils::FileName::fromString(progFilesX86 + "/CMake/bin"));
         }
     }
 
     if (HostOsInfo::isMacHost()) {
-        path.append("/Applications/CMake.app/Contents/bin");
+        path.append(Utils::FileName::fromString("/Applications/CMake.app/Contents/bin"));
-        path.append("/usr/local/bin");
+        path.append(Utils::FileName::fromString("/usr/local/bin"));
-        path.append("/opt/local/bin");
+        path.append(Utils::FileName::fromString("/opt/local/bin"));
     }
 
-    QStringList execs = env.appendExeExtensions(QLatin1String("cmake"));
+    const QStringList execs = env.appendExeExtensions(QLatin1String("cmake"));
 
-    foreach (QString base, path) {
+    FileNameList suspects;
-        const QChar slash = QLatin1Char('/');
+    foreach (const Utils::FileName &base, path) {
         if (base.isEmpty())
             continue;
-        // Avoid turning '/' into '//' on Windows which triggers Windows to check
-        // for network drives!
-        if (!base.endsWith(slash))
-            base += slash;
 
-        foreach (const QString &exec, execs) {
+        QFileInfo fi;
-            QFileInfo fi(base + exec);
+        for (const QString &exec : execs) {
+            fi.setFile(base.toString(), exec);
             if (fi.exists() && fi.isFile() && fi.isExecutable())
                 suspects << FileName::fromString(fi.absoluteFilePath());
         }

src/plugins/debugger/debuggeritemmanager.cpp

@@ -34,6 +34,7 @@
 
 #include <projectexplorer/projectexplorerconstants.h>
 
+#include <utils/algorithm.h>
 #include <utils/detailswidget.h>
 #include <utils/environment.h>
 #include <utils/fileutils.h>
@@ -750,13 +751,13 @@ void DebuggerItemManagerPrivate::autoDetectGdbOrLldbDebuggers()
         }
     }
 
-    QStringList path = Environment::systemEnvironment().path();
+    Utils::FileNameList path = Environment::systemEnvironment().path();
-    path.removeDuplicates();
+    path = Utils::filteredUnique(path);
     QDir dir;
     dir.setNameFilters(filters);
     dir.setFilter(QDir::Files | QDir::Executable);
-    foreach (const QString &base, path) {
+    foreach (const Utils::FileName &base, path) {
-        dir.setPath(base);
+        dir.setPath(base.toFileInfo().absoluteFilePath());
         foreach (const QString &entry, dir.entryList()) {
             if (entry.startsWith(QLatin1String("lldb-platform-"))
                     || entry.startsWith(QLatin1String("lldb-gdbserver-"))) {

src/plugins/debugger/debuggerkitinformation.cpp

@@ -59,12 +59,12 @@ DebuggerKitInformation::DebuggerKitInformation()
 QVariant DebuggerKitInformation::defaultValue(const Kit *k) const
 {
     const Abi toolChainAbi = ToolChainKitInformation::targetAbi(k);
-    const QStringList paths = Environment::systemEnvironment().path();
+    const Utils::FileNameList paths = Environment::systemEnvironment().path();
     QVariant nextBestFit;
     foreach (const DebuggerItem &item, DebuggerItemManager::debuggers()) {
         foreach (const Abi targetAbi, item.abis()) {
             if (targetAbi.isCompatibleWith(toolChainAbi)) {
-                if (paths.contains(item.command().toFileInfo().absolutePath()))
+                if (paths.contains(item.command()))
                     return item.id(); // prefer debuggers found in PATH over those found elsewhere
                 if (nextBestFit.isNull())
                     nextBestFit = item.id();

src/plugins/projectexplorer/abstractmsvctoolchain.cpp

@@ -238,7 +238,7 @@ QString AbstractMsvcToolChain::makeCommand(const Utils::Environment &environment
     Utils::FileName tmp;
 
     if (useJom) {
-        tmp = environment.searchInPath(jom, QStringList(QCoreApplication::applicationDirPath()));
+        tmp = environment.searchInPath(jom, {Utils::FileName::fromString(QCoreApplication::applicationDirPath())});
         if (!tmp.isEmpty())
             return tmp.toString();
     }
@@ -255,8 +255,8 @@ Utils::FileName AbstractMsvcToolChain::compilerCommand() const
     Utils::Environment env = Utils::Environment::systemEnvironment();
     addToEnvironment(env);
 
-    Utils::FileName clexe = env.searchInPath(QLatin1String("cl.exe"), QStringList(), [](const QString &name) {
+    Utils::FileName clexe = env.searchInPath(QLatin1String("cl.exe"), {}, [](const Utils::FileName &name) {
-        QDir dir(QDir::cleanPath(QFileInfo(name).absolutePath() + QStringLiteral("/..")));
+        QDir dir(QDir::cleanPath(name.toFileInfo().absolutePath() + QStringLiteral("/..")));
         do {
             if (QFile::exists(dir.absoluteFilePath(QStringLiteral("vcvarsall.bat")))
                     || QFile::exists(dir.absolutePath() + "/Auxiliary/Build/vcvarsall.bat"))

src/plugins/projectexplorer/customexecutablerunconfiguration.cpp

@@ -203,7 +203,7 @@ bool CustomExecutableRunConfiguration::validateExecutable(QString *executable, Q
     if (aspect)
         env = aspect->environment();
     const Utils::FileName exec = env.searchInPath(macroExpander()->expand(m_executable),
-                                                  QStringList(workingDirectory()));
+                                                  {Utils::FileName::fromString(workingDirectory())});
     if (exec.isEmpty()) {
         if (errorMessage)
             *errorMessage = tr("The executable\n%1\ncannot be found in the path.").

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -431,10 +431,10 @@ bool GccToolChain::isValid() const
 static Utils::FileName findLocalCompiler(const Utils::FileName &compilerPath,
                                          const Environment &env)
 {
-    const Utils::FileName path = env.searchInPath(compilerPath.fileName(), QStringList(),
+    const Utils::FileName path = env.searchInPath(compilerPath.fileName(), Utils::FileNameList(),
-                                                  [](const QString &pathEntry) {
+                                                  [](const FileName &pathEntry) {
-        return !pathEntry.contains("icecc")
+        return !pathEntry.toString().contains("icecc")
-            && !pathEntry.contains("distcc");
+            && !pathEntry.toString().contains("distcc");
     });
 
     QTC_ASSERT(!path.isEmpty(), return compilerPath);

src/plugins/projectexplorer/processparameters.cpp

@@ -125,7 +125,7 @@ QString ProcessParameters::effectiveCommand() const
         if (m_macroExpander)
             cmd = m_macroExpander->expand(cmd);
         m_effectiveCommand =
-                m_environment.searchInPath(cmd, QStringList(effectiveWorkingDirectory())).toString();
+                m_environment.searchInPath(cmd, {Utils::FileName::fromString(effectiveWorkingDirectory())}).toString();
         m_commandMissing = m_effectiveCommand.isEmpty();
         if (m_commandMissing)
             m_effectiveCommand = cmd;

src/plugins/vcsbase/vcsbaseclientsettings.cpp

@@ -25,6 +25,7 @@
 
 #include "vcsbaseclientsettings.h"
 
+#include <utils/algorithm.h>
 #include <utils/environment.h>
 #include <utils/fileutils.h>
 #include <utils/hostosinfo.h>
@@ -355,8 +356,10 @@ QVariant::Type VcsBaseClientSettings::valueType(const QString &key) const
 Utils::FileName VcsBaseClientSettings::binaryPath() const
 {
     if (d->m_binaryFullPath.isEmpty()) {
+        const Utils::FileNameList searchPaths
+                = Utils::transform(searchPathList(), [](const QString &s) { return Utils::FileName::fromString(s); });
         d->m_binaryFullPath = Utils::Environment::systemEnvironment().searchInPath(
-                    stringValue(binaryPathKey), searchPathList());
+                    stringValue(binaryPathKey), searchPaths);
     }
     return d->m_binaryFullPath;
 }