ClangTools/QMake: Stop analyzing files not part of build configuration

...for the qmake project manager.

When parsing the project files, remember whether a file was discovered
by the exact or cumulative parse. Only files that were discovered by the
exact parse are considered "active" and thus part of the build
configuration. The others are not offered for selection.

Fixes: QTCREATORBUG-16016
Started-by: Oswald Buddenhagen <oswald.buddenhagen@qt.io>
Change-Id: I7a28b4de15e048975d7f0cd737dd8c11f744315b
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@gmx.de>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/clangtools/clangtool.cpp

@@ -77,8 +77,10 @@ static FileInfos sortedFileInfos(const QVector<CppTools::ProjectPart::Ptr> &proj
             if (file.path == CppTools::CppModelManager::configurationFileName())
                 continue;
 
-            if (CppTools::ProjectFile::isSource(file.kind)) {
+            if (file.active && CppTools::ProjectFile::isSource(file.kind)) {
-                fileInfos.emplace_back(Utils::FileName::fromString(file.path), file.kind, projectPart);
+                fileInfos.emplace_back(Utils::FileName::fromString(file.path),
+                                       file.kind,
+                                       projectPart);
             }
         }
     }

src/plugins/cppeditor/cppcodemodelinspectordialog.cpp

@@ -262,6 +262,11 @@ QVariant ProjectFilesModel::data(const QModelIndex &index, int role) const
         } else if (column == FilePathColumn) {
             return m_files.at(row).path;
         }
+    } else if (role == Qt::ForegroundRole) {
+        if (!m_files.at(index.row()).active) {
+            return QApplication::palette().color(QPalette::ColorGroup::Disabled,
+                                                 QPalette::ColorRole::Text);
+        }
     }
     return QVariant();
 }

src/plugins/cpptools/cppcodemodelinspectordumper.cpp

@@ -515,8 +515,10 @@ void Dumper::dumpProjectInfos( const QList<ProjectInfo> &projectInfos)
             if (!part->files.isEmpty()) {
                 m_out << i3 << "Files:{{{4\n";
                 foreach (const ProjectFile &projectFile, part->files) {
-                    m_out << i4 << Utils::toString(projectFile.kind) << ": " << projectFile.path
+                    m_out << i4 << Utils::toString(projectFile.kind) << ": " << projectFile.path;
-                          << "\n";
+                    if (!projectFile.active)
+                        m_out << " (inactive)";
+                    m_out << "\n";
                 }
             }
 

src/plugins/cpptools/cppprojectfile.cpp

@@ -33,16 +33,18 @@
 
 namespace CppTools {
 
-ProjectFile::ProjectFile(const QString &filePath, Kind kind)
+ProjectFile::ProjectFile(const QString &filePath, Kind kind, bool active)
     : path(filePath)
     , kind(kind)
+    , active(active)
 {
 }
 
 bool ProjectFile::operator==(const ProjectFile &other) const
 {
-    return path == other.path
+    return active == other.active
-        && kind == other.kind;
+        && kind == other.kind
+        && path == other.path;
 }
 
 ProjectFile::Kind ProjectFile::classify(const QString &filePath)

src/plugins/cpptools/cppprojectfile.h

@@ -61,12 +61,13 @@ public:
 
 public:
     ProjectFile() = default;
-    ProjectFile(const QString &filePath, Kind kind);
+    ProjectFile(const QString &filePath, Kind kind, bool active = true);
 
     bool operator==(const ProjectFile &other) const;
 
     QString path;
     Kind kind = Unclassified;
+    bool active = true;
 };
 
 using ProjectFiles = QVector<ProjectFile>;

src/plugins/cpptools/cppprojectfilecategorizer.cpp

@@ -25,6 +25,8 @@
 
 #include "cppprojectfilecategorizer.h"
 
+#include <utils/algorithm.h>
+
 namespace CppTools {
 
 ProjectFileCategorizer::ProjectFileCategorizer(const QString &projectPartName,
@@ -32,7 +34,7 @@ ProjectFileCategorizer::ProjectFileCategorizer(const QString &projectPartName,
                                                FileClassifier fileClassifier)
     : m_partName(projectPartName)
 {
-    const QStringList ambiguousHeaders = classifyFiles(filePaths, fileClassifier);
+    const ProjectFiles ambiguousHeaders = classifyFiles(filePaths, fileClassifier);
     expandSourcesWithAmbiguousHeaders(ambiguousHeaders);
 
     m_partCount = (m_cSources.isEmpty() ? 0 : 1)
@@ -50,35 +52,35 @@ QString ProjectFileCategorizer::partName(const QString &languageName) const
     return m_partName;
 }
 
-QStringList ProjectFileCategorizer::classifyFiles(const QStringList &filePaths,
+ProjectFiles ProjectFileCategorizer::classifyFiles(const QStringList &filePaths,
-                                                  FileClassifier fileClassifier)
+                                                   FileClassifier fileClassifier)
 {
-    QStringList ambiguousHeaders;
+    ProjectFiles ambiguousHeaders;
 
     foreach (const QString &filePath, filePaths) {
-        const ProjectFile::Kind kind = fileClassifier
+        const ProjectFile projectFile = fileClassifier
                 ? fileClassifier(filePath)
-                : ProjectFile::classify(filePath);
+                : ProjectFile(filePath, ProjectFile::classify(filePath));
 
-        switch (kind) {
+        switch (projectFile.kind) {
         case ProjectFile::AmbiguousHeader:
-            ambiguousHeaders += filePath;
+            ambiguousHeaders += projectFile;
             break;
         case ProjectFile::CXXSource:
         case ProjectFile::CXXHeader:
-            m_cxxSources += ProjectFile(filePath, kind);
+            m_cxxSources += projectFile;
             break;
         case ProjectFile::ObjCXXSource:
         case ProjectFile::ObjCXXHeader:
-            m_objcxxSources += ProjectFile(filePath, kind);
+            m_objcxxSources += projectFile;
             break;
         case ProjectFile::CSource:
         case ProjectFile::CHeader:
-            m_cSources += ProjectFile(filePath, kind);
+            m_cSources += projectFile;
             break;
         case ProjectFile::ObjCSource:
         case ProjectFile::ObjCHeader:
-            m_objcSources += ProjectFile(filePath, kind);
+            m_objcSources += projectFile;
             break;
         default:
             continue;
@@ -88,19 +90,15 @@ QStringList ProjectFileCategorizer::classifyFiles(const QStringList &filePaths,
     return ambiguousHeaders;
 }
 
-static ProjectFiles toProjectFilesWithKind(const QStringList &filePaths,
+static ProjectFiles toProjectFilesWithKind(const ProjectFiles &ambiguousHeaders,
-                                           const ProjectFile::Kind kind)
+                                           const ProjectFile::Kind overriddenKind)
 {
-    ProjectFiles projectFiles;
+    return Utils::transform(ambiguousHeaders, [overriddenKind](const ProjectFile &projectFile) {
-    projectFiles.reserve(filePaths.size());
+        return ProjectFile(projectFile.path, overriddenKind, projectFile.active);
-
+    });
-    foreach (const QString &filePath, filePaths)
-        projectFiles += ProjectFile(filePath, kind);
-
-    return projectFiles;
 }
 
-void ProjectFileCategorizer::expandSourcesWithAmbiguousHeaders(const QStringList &ambiguousHeaders)
+void ProjectFileCategorizer::expandSourcesWithAmbiguousHeaders(const ProjectFiles &ambiguousHeaders)
 {
     const bool hasC = !m_cSources.isEmpty();
     const bool hasCxx = !m_cxxSources.isEmpty();

src/plugins/cpptools/cppprojectfilecategorizer.h

@@ -59,8 +59,8 @@ public:
     QString partName(const QString &languageName) const;
 
 private:
-    QStringList classifyFiles(const QStringList &filePaths, FileClassifier fileClassifier);
+    ProjectFiles classifyFiles(const QStringList &filePaths, FileClassifier fileClassifier);
-    void expandSourcesWithAmbiguousHeaders(const QStringList &ambiguousHeaders);
+    void expandSourcesWithAmbiguousHeaders(const ProjectFiles &ambiguousHeaders);
 
 private:
     QString m_partName;

src/plugins/cpptools/cpprawprojectpart.h

@@ -57,7 +57,7 @@ public:
     void setDisplayName(const QString &displayName);
 
     // FileClassifier must be thread-safe.
-    using FileClassifier = std::function<ProjectFile::Kind (const QString &filePath)>;
+    using FileClassifier = std::function<ProjectFile(const QString &filePath)>;
     void setFiles(const QStringList &files, FileClassifier fileClassifier = FileClassifier());
 
     void setProjectFileLocation(const QString &projectFile, int line = -1, int column = -1);

src/plugins/qbsprojectmanager/qbsproject.cpp

@@ -1061,7 +1061,8 @@ void QbsProject::updateCppCodeModel()
             rpp.setPreCompiledHeaders(pchFiles.toList());
             rpp.setFiles(grp.allFilePaths(), [filePathToSourceArtifact](const QString &filePath) {
                 // Keep this lambda thread-safe!
-                return cppFileType(filePathToSourceArtifact.value(filePath));
+                return CppTools::ProjectFile(filePath,
+                                             cppFileType(filePathToSourceArtifact.value(filePath)));
             });
 
             rpps.append(rpp);

src/plugins/qmakeprojectmanager/qmakeparsernodes.cpp

@@ -1400,12 +1400,13 @@ QmakeEvalResult *QmakeProFile::evaluate(const QmakeEvalInput &input)
                                                             input.buildDirectory, input.projectDir);
         result->newVarValues[Variable::CppFlags] = exactReader->values(QLatin1String("QMAKE_CXXFLAGS"));
         result->newVarValues[Variable::CFlags] = exactReader->values(QLatin1String("QMAKE_CFLAGS"));
-        result->newVarValues[Variable::Source] =
+        result->newVarValues[Variable::ExactSource] =
                 fileListForVar(exactSourceFiles, QLatin1String("SOURCES")) +
-                fileListForVar(cumulativeSourceFiles, QLatin1String("SOURCES")) +
                 fileListForVar(exactSourceFiles, QLatin1String("HEADERS")) +
+                fileListForVar(exactSourceFiles, QLatin1String("OBJECTIVE_HEADERS"));
+        result->newVarValues[Variable::CumulativeSource] =
+                fileListForVar(cumulativeSourceFiles, QLatin1String("SOURCES")) +
                 fileListForVar(cumulativeSourceFiles, QLatin1String("HEADERS")) +
-                fileListForVar(exactSourceFiles, QLatin1String("OBJECTIVE_HEADERS")) +
                 fileListForVar(cumulativeSourceFiles, QLatin1String("OBJECTIVE_HEADERS"));
         result->newVarValues[Variable::UiDir] = QStringList() << uiDirPath(exactReader, input.buildDirectory);
         result->newVarValues[Variable::HeaderExtension] = QStringList() << exactReader->value(QLatin1String("QMAKE_EXT_H"));

src/plugins/qmakeprojectmanager/qmakeparsernodes.h

@@ -69,7 +69,8 @@ enum class Variable {
     IncludePath,
     CppFlags,
     CFlags,
-    Source,
+    ExactSource,
+    CumulativeSource,
     ExactResource,
     CumulativeResource,
     UiDir,

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -322,7 +322,8 @@ void QmakeProject::updateCppCodeModel()
         rpp.setHeaderPaths(headerPaths);
 
         // Files and generators
-        QStringList fileList = pro->variableValue(Variable::Source);
+        const QStringList cumulativeSourceFiles = pro->variableValue(Variable::CumulativeSource);
+        QStringList fileList = pro->variableValue(Variable::ExactSource) + cumulativeSourceFiles;
         QList<ProjectExplorer::ExtraCompiler *> proGenerators = pro->extraCompilers();
         foreach (ProjectExplorer::ExtraCompiler *ec, proGenerators) {
             ec->forEachTarget([&](const Utils::FileName &generatedFile) {
@@ -331,7 +332,12 @@ void QmakeProject::updateCppCodeModel()
         }
         generators.append(proGenerators);
         fileList.prepend(CppTools::CppModelManager::configurationFileName());
-        rpp.setFiles(fileList);
+        rpp.setFiles(fileList, [cumulativeSourceFiles](const QString &filePath) {
+            // Keep this lambda thread-safe!
+            return CppTools::ProjectFile(filePath,
+                                         CppTools::ProjectFile::classify(filePath),
+                                         !cumulativeSourceFiles.contains(filePath));
+        });
 
         rpps.append(rpp);
     }