ProjectExplorer: Proliferate FilePath a bit

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

src/plugins/autotoolsprojectmanager/autotoolsbuildsystem.cpp

@@ -14,6 +14,7 @@
 #include <utils/qtcassert.h>
 
 using namespace ProjectExplorer;
+using namespace Utils;
 
 namespace AutotoolsProjectManager::Internal {
 
@@ -140,7 +141,7 @@ void AutotoolsBuildSystem::updateCppCodeModel()
     if (cxxflags.isEmpty())
         cxxflags = cflags;
 
-    const QString includeFileBaseDir = projectDirectory().toString();
+    const FilePath includeFileBaseDir = projectDirectory();
     rpp.setFlagsForC({kitInfo.cToolChain, cflags, includeFileBaseDir});
     rpp.setFlagsForCxx({kitInfo.cxxToolChain, cxxflags, includeFileBaseDir});
 

src/plugins/cmakeprojectmanager/cmakebuildsystem.cpp

@@ -601,7 +601,7 @@ void CMakeBuildSystem::updateProjectData()
     for (RawProjectPart &rpp : rpps) {
         rpp.setQtVersion(
                     kitInfo.projectPartQtVersion); // TODO: Check if project actually uses Qt.
-        const QString includeFileBaseDir = buildConfiguration()->buildDirectory().toString();
+        const FilePath includeFileBaseDir = buildConfiguration()->buildDirectory();
         QStringList cxxFlags = rpp.flagsForCxx.commandLineFlags;
         QStringList cFlags = rpp.flagsForC.commandLineFlags;
         addTargetFlagForIos(cxxFlags, cFlags, this, [this] {

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp

@@ -148,8 +148,8 @@ void addDriverModeFlagIfNeeded(const ToolChain *toolchain,
 RawProjectPart makeRawProjectPart(const Utils::FilePath &projectFile,
                                   Kit *kit,
                                   ProjectExplorer::KitInfo &kitInfo,
-                                  const QString &workingDir,
+                                  const FilePath &workingDir,
-                                  const Utils::FilePath &fileName,
+                                  const FilePath &filePath,
                                   QStringList flags)
 {
     HeaderPaths headerPaths;
@@ -157,7 +157,7 @@ RawProjectPart makeRawProjectPart(const Utils::FilePath &projectFile,
     CppEditor::ProjectFile::Kind fileKind = CppEditor::ProjectFile::Unclassified;
 
     const QStringList originalFlags = flags;
-    filteredFlags(fileName.fileName(),
+    filteredFlags(filePath,
                   workingDir,
                   flags,
                   headerPaths,
@@ -166,10 +166,12 @@ RawProjectPart makeRawProjectPart(const Utils::FilePath &projectFile,
                   kitInfo.sysRootPath);
 
     RawProjectPart rpp;
+
     rpp.setProjectFileLocation(projectFile.toString());
-    rpp.setBuildSystemTarget(workingDir);
+    rpp.setBuildSystemTarget(workingDir.path());
-    rpp.setDisplayName(fileName.fileName());
+    rpp.setDisplayName(filePath.fileName());
-    rpp.setFiles({fileName.toString()});
+    rpp.setFiles({filePath.toFSPathString()});
+
     rpp.setHeaderPaths(headerPaths);
     rpp.setMacros(macros);
 

src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp

@@ -92,7 +92,9 @@ public:
 
     QStringList getFilteredFlags()
     {
-        filteredFlags(fileName, workingDir, flags, headerPaths, macros, fileKind, sysRoot);
+        filteredFlags(FilePath::fromString(fileName),
+                      FilePath::fromString(workingDir),
+                      flags, headerPaths, macros, fileKind, sysRoot);
         return flags;
     }
 

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseutils.cpp

@@ -22,15 +22,6 @@ using namespace Utils;
 namespace CompilationDatabaseProjectManager {
 namespace Internal {
 
-static QString updatedPathFlag(const QString &pathStr, const QString &workingDir)
-{
-    QString result = pathStr;
-    if (QDir(pathStr).isRelative())
-        result = workingDir + "/" + pathStr;
-
-    return result;
-}
-
 static CppEditor::ProjectFile::Kind fileKindFromString(QString flag)
 {
     using namespace CppEditor;
@@ -86,13 +77,13 @@ QStringList filterFromFileName(const QStringList &flags, QString fileName)
     return result;
 }
 
-void filteredFlags(const QString &fileName,
+void filteredFlags(const FilePath &filePath,
-                   const QString &workingDir,
+                   const FilePath &workingDir,
                    QStringList &flags,
                    HeaderPaths &headerPaths,
                    Macros &macros,
                    CppEditor::ProjectFile::Kind &fileKind,
-                   Utils::FilePath &sysRoot)
+                   FilePath &sysRoot)
 {
     if (flags.empty())
         return;
@@ -113,7 +104,7 @@ void filteredFlags(const QString &fileName,
         }
 
         if (includePathType) {
-            const QString pathStr = updatedPathFlag(flag, workingDir);
+            const QString pathStr = workingDir.resolvePath(flag).toString();
             headerPaths.append({pathStr, includePathType.value()});
             includePathType.reset();
             continue;
@@ -152,7 +143,7 @@ void filteredFlags(const QString &fileName,
             return flag.startsWith(opt) && flag != opt;
         });
         if (!includeOpt.isEmpty()) {
-            const QString pathStr = updatedPathFlag(flag.mid(includeOpt.length()), workingDir);
+            const QString pathStr = workingDir.resolvePath(flag.mid(includeOpt.length())).toString();
             headerPaths.append({pathStr, userIncludeFlags.contains(includeOpt)
                                 ? HeaderPathType::User : HeaderPathType::System});
             continue;
@@ -182,14 +173,14 @@ void filteredFlags(const QString &fileName,
 
         if (flag.startsWith("--sysroot=")) {
             if (sysRoot.isEmpty())
-                sysRoot = FilePath::fromUserInput(updatedPathFlag(flag.mid(10), workingDir));
+                sysRoot = workingDir.resolvePath(flag.mid(10));
             continue;
         }
 
         if ((flag.startsWith("-std=") || flag.startsWith("/std:"))
                 && fileKind == CppEditor::ProjectFile::Unclassified) {
             const bool cpp = (flag.contains("c++") || flag.contains("gnu++"));
-            if (CppEditor::ProjectFile::isHeader(CppEditor::ProjectFile::classify(fileName)))
+            if (CppEditor::ProjectFile::isHeader(CppEditor::ProjectFile::classify(filePath.path())))
                 fileKind = cpp ? CppEditor::ProjectFile::CXXHeader : CppEditor::ProjectFile::CHeader;
             else
                 fileKind = cpp ? CppEditor::ProjectFile::CXXSource : CppEditor::ProjectFile::CSource;
@@ -203,7 +194,7 @@ void filteredFlags(const QString &fileName,
     }
 
     if (fileKind == CppEditor::ProjectFile::Unclassified)
-        fileKind = CppEditor::ProjectFile::classify(fileName);
+        fileKind = CppEditor::ProjectFile::classify(filePath.path());
 
     flags = filtered;
 }

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseutils.h

@@ -4,10 +4,8 @@
 #pragma once
 
 #include <cppeditor/cppprojectfile.h>
-#include <utils/filepath.h>
 
 #include <QHash>
-#include <QStringList>
 
 namespace ProjectExplorer {
 class HeaderPath;
@@ -21,7 +19,7 @@ class DbEntry {
 public:
     QStringList flags;
     Utils::FilePath fileName;
-    QString workingDir;
+    Utils::FilePath workingDir;
 };
 
 class DbContents {
@@ -35,8 +33,8 @@ using MimeBinaryCache = QHash<QString, bool>;
 
 QStringList filterFromFileName(const QStringList &flags, QString baseName);
 
-void filteredFlags(const QString &fileName,
+void filteredFlags(const Utils::FilePath &filePath,
-                   const QString &workingDir,
+                   const Utils::FilePath &workingDir,
                    QStringList &flags,
                    QVector<ProjectExplorer::HeaderPath> &headerPaths,
                    QVector<ProjectExplorer::Macro> &macros,

src/plugins/compilationdatabaseprojectmanager/compilationdbparser.cpp

@@ -182,7 +182,7 @@ std::vector<DbEntry> CompilationDbParser::readJsonObjects() const
         const Utils::FilePath filePath = jsonObjectFilePath(object);
         const QStringList flags = filterFromFileName(jsonObjectFlags(object, flagsCache),
                                                      filePath.fileName());
-        result.push_back({flags, filePath, object["directory"].toString()});
+        result.push_back({flags, filePath, FilePath::fromUserInput(object["directory"].toString())});
 
         objectStart = m_projectFileContents.indexOf('{', objectEnd + 1);
         objectEnd = m_projectFileContents.indexOf('}', objectStart + 1);

src/plugins/genericprojectmanager/genericproject.cpp

@@ -569,8 +569,8 @@ void GenericBuildSystem::refreshCppCodeModel()
     rpp.setQtVersion(kitInfo.projectPartQtVersion);
     rpp.setHeaderPaths(m_projectIncludePaths);
     rpp.setConfigFileName(m_configFileName);
-    rpp.setFlagsForCxx({nullptr, m_cxxflags, projectDirectory().toString()});
+    rpp.setFlagsForCxx({nullptr, m_cxxflags, projectDirectory()});
-    rpp.setFlagsForC({nullptr, m_cflags, projectDirectory().toString()});
+    rpp.setFlagsForC({nullptr, m_cflags, projectDirectory()});
 
     static const auto sourceFilesToStringList = [](const SourceFiles &sourceFiles) {
         return Utils::transform(sourceFiles, [](const SourceFile &f) {

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -569,7 +569,7 @@ WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
     return flags;
 }
 
-QStringList GccToolChain::includedFiles(const QStringList &flags, const QString &directoryPath) const
+FilePaths GccToolChain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const
 {
     return ToolChain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
 }

src/plugins/projectexplorer/gcctoolchain.h

@@ -55,8 +55,8 @@ public:
 
     Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     Utils::WarningFlags warningFlags(const QStringList &cflags) const override;
-    QStringList includedFiles(const QStringList &flags,
+    Utils::FilePaths includedFiles(const QStringList &flags,
-                              const QString &directoryPath) const override;
+                                   const Utils::FilePath &directoryPath) const override;
 
     MacroInspectionRunner createMacroInspectionRunner() const override;
     BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(const Utils::Environment &env) const override;

src/plugins/projectexplorer/msvctoolchain.cpp

@@ -1124,8 +1124,8 @@ WarningFlags MsvcToolChain::warningFlags(const QStringList &cflags) const
     return flags;
 }
 
-QStringList MsvcToolChain::includedFiles(const QStringList &flags,
+FilePaths MsvcToolChain::includedFiles(const QStringList &flags,
-                                         const QString &directoryPath) const
+                                       const FilePath &directoryPath) const
 {
     return ToolChain::includedFiles("/FI", flags, directoryPath, PossiblyConcatenatedFlag::Yes);
 }

src/plugins/projectexplorer/msvctoolchain.h

@@ -55,8 +55,8 @@ public:
     MacroInspectionRunner createMacroInspectionRunner() const override;
     Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     Utils::WarningFlags warningFlags(const QStringList &cflags) const override;
-    QStringList includedFiles(const QStringList &flags,
+    Utils::FilePaths includedFiles(const QStringList &flags,
-                              const QString &directoryPath) const override;
+                              const Utils::FilePath &directoryPath) const override;
     BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
             const Utils::Environment &env) const override;
     void addToEnvironment(Utils::Environment &env) const override;

src/plugins/projectexplorer/rawprojectpart.cpp

@@ -11,13 +11,14 @@
 #include "target.h"
 
 #include <ios/iosconstants.h>
+
 #include <utils/algorithm.h>
 
 namespace ProjectExplorer {
 
 RawProjectPartFlags::RawProjectPartFlags(const ToolChain *toolChain,
                                          const QStringList &commandLineFlags,
-                                         const QString &includeFileBaseDir)
+                                         const Utils::FilePath &includeFileBaseDir)
 {
     // Keep the following cheap/non-blocking for the ui thread. Expensive
     // operations are encapsulated in ToolChainInfo as "runners".
@@ -25,7 +26,8 @@ RawProjectPartFlags::RawProjectPartFlags(const ToolChain *toolChain,
     if (toolChain) {
         warningFlags = toolChain->warningFlags(commandLineFlags);
         languageExtensions = toolChain->languageExtensions(commandLineFlags);
-        includedFiles = toolChain->includedFiles(commandLineFlags, includeFileBaseDir);
+        includedFiles = Utils::transform(toolChain->includedFiles(commandLineFlags, includeFileBaseDir),
+                                         &Utils::FilePath::toFSPathString);
     }
 }
 

src/plugins/projectexplorer/rawprojectpart.h

@@ -37,7 +37,7 @@ class PROJECTEXPLORER_EXPORT RawProjectPartFlags
 public:
     RawProjectPartFlags() = default;
     RawProjectPartFlags(const ToolChain *toolChain, const QStringList &commandLineFlags,
-                        const QString &includeFileBaseDir);
+                        const Utils::FilePath &includeFileBaseDir);
 
 public:
     QStringList commandLineFlags;

src/plugins/projectexplorer/toolchain.cpp

@@ -192,7 +192,7 @@ bool ToolChain::isValid() const
     return d->m_isValid.value_or(false);
 }
 
-QStringList ToolChain::includedFiles(const QStringList &flags, const QString &directory) const
+FilePaths ToolChain::includedFiles(const QStringList &flags, const FilePath &directory) const
 {
     Q_UNUSED(flags)
     Q_UNUSED(directory)
@@ -466,12 +466,12 @@ Utils::LanguageVersion ToolChain::languageVersion(const Utils::Id &language, con
     }
 }
 
-QStringList ToolChain::includedFiles(const QString &option,
+FilePaths ToolChain::includedFiles(const QString &option,
                                    const QStringList &flags,
-                                     const QString &directoryPath,
+                                   const FilePath &directoryPath,
                                    PossiblyConcatenatedFlag possiblyConcatenated)
 {
-    QStringList result;
+    FilePaths result;
 
     for (int i = 0; i < flags.size(); ++i) {
         QString includeFile;
@@ -484,11 +484,8 @@ QStringList ToolChain::includedFiles(const QString &option,
         if (includeFile.isEmpty() && flag == option && i + 1 < flags.size())
             includeFile = flags[++i];
 
-        if (!includeFile.isEmpty()) {
+        if (!includeFile.isEmpty())
-            if (!QFileInfo(includeFile).isAbsolute())
+            result.append(directoryPath.resolvePath(includeFile));
-                includeFile = directoryPath + "/" + includeFile;
-            result.append(QDir::cleanPath(includeFile));
-        }
     }
 
     return result;

src/plugins/projectexplorer/toolchain.h

@@ -102,7 +102,7 @@ public:
 
     virtual Utils::LanguageExtensions languageExtensions(const QStringList &cxxflags) const = 0;
     virtual Utils::WarningFlags warningFlags(const QStringList &cflags) const = 0;
-    virtual QStringList includedFiles(const QStringList &flags, const QString &directory) const;
+    virtual Utils::FilePaths includedFiles(const QStringList &flags, const Utils::FilePath &directory) const;
     virtual QString sysRoot() const;
 
     QString explicitCodeModelTargetTriple() const;
@@ -184,9 +184,9 @@ protected:
     virtual bool fromMap(const QVariantMap &data);
 
     enum class PossiblyConcatenatedFlag { No, Yes };
-    static QStringList includedFiles(const QString &option,
+    static Utils::FilePaths includedFiles(const QString &option,
                                           const QStringList &flags,
-                                     const QString &directoryPath,
+                                          const Utils::FilePath &directoryPath,
                                           PossiblyConcatenatedFlag possiblyConcatenated);
 
 private:

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -337,7 +337,7 @@ void QmakeBuildSystem::updateCppCodeModel()
             rpp.setBuildTargetType(BuildTargetType::Unknown);
             break;
         }
-        const QString includeFileBaseDir = pro->sourceDir().toString();
+        const FilePath includeFileBaseDir = pro->sourceDir();
 
         QStringList cxxArgs = pro->variableValue(Variable::CppFlags);
         QStringList cArgs = pro->variableValue(Variable::CFlags);