Add groups support for MS build project

Added the ability to create Visual Studio project
filters according to groups in the qbs configuration
file. Information about standard filters has been
moved to static constants to reduce the number of
memory allocations when processing a large number
of qbs products.

Change-Id: I9b230f28ae0f7ea0ccd5aab9994ba370b4ba3b4a
Reviewed-by: Ivan Komissarov <ABBAPOH@gmail.com>

1 files changed, 169 insertions, 76 deletions

diff --git a/src/plugins/generator/visualstudio/msbuildfiltersproject.cpp b/src/plugins/generator/visualstudio/msbuildfiltersproject.cpp
index 039b1173e..48d967c77 100644
--- a/src/plugins/generator/visualstudio/msbuildfiltersproject.cpp
+++ b/src/plugins/generator/visualstudio/msbuildfiltersproject.cpp
@@ -45,110 +45,203 @@
 
 namespace qbs {
 
-static QStringList sourceFileExtensions()
+namespace {
+
+const QStringList & sourceFileExtensions()
 {
-    return {QStringLiteral("c"), QStringLiteral("C"), QStringLiteral("cpp"),
-            QStringLiteral("cxx"), QStringLiteral("c++"), QStringLiteral("cc"),
-            QStringLiteral("cs"), QStringLiteral("def"), QStringLiteral("java"),
-            QStringLiteral("m"), QStringLiteral("mm")};
+    static const QStringList EXTENSIONS{
+        QStringLiteral("c"),
+        QStringLiteral("C"),
+        QStringLiteral("cpp"),
+        QStringLiteral("cxx"),
+        QStringLiteral("c++"),
+        QStringLiteral("cc"),
+        QStringLiteral("cs"),
+        QStringLiteral("def"),
+        QStringLiteral("java"),
+        QStringLiteral("m"),
+        QStringLiteral("mm")};
+
+    return EXTENSIONS;
 }
 
-static QStringList headerFileExtensions()
+const QStringList & headerFileExtensions()
 {
-    return {QStringLiteral("h"), QStringLiteral("H"), QStringLiteral("hpp"),
-            QStringLiteral("hxx"),  QStringLiteral("h++")};
+    static const QStringList EXTENSIONS{
+        QStringLiteral("h"),
+        QStringLiteral("H"),
+        QStringLiteral("hpp"),
+        QStringLiteral("hxx"),
+        QStringLiteral("h++")};
+
+    return EXTENSIONS;
 }
 
-static std::vector<MSBuildFilter *> defaultItemGroupFilters(IMSBuildItemGroup *parent = nullptr)
+struct FilterInfo
+{
+    QString name;
+    QList<QString> extensions;
+    bool parseFiles{ true };
+    bool sourceControlFiles{ true };
+};
+
+const std::vector<FilterInfo> & getDefaultFilterInfo()
 {
-    const auto sourceFilter = new MSBuildFilter(QStringLiteral("Source Files"), sourceFileExtensions(), parent);
-    const auto headerFilter = new MSBuildFilter(QStringLiteral("Header Files"), headerFileExtensions(), parent);
-
-    const auto formFilter = new MSBuildFilter(QStringLiteral("Form Files"),
-                                              QStringList() << QStringLiteral("ui"), parent);
-    const auto resourceFilter = new MSBuildFilter(QStringLiteral("Resource Files"),
-                                                  QStringList()
-                                                  << QStringLiteral("qrc")
-                                                  << QStringLiteral("rc")
-                                                  << QStringLiteral("*"), parent);
-    resourceFilter->setParseFiles(false);
-    const auto generatedFilter = new MSBuildFilter(QStringLiteral("Generated Files"),
-                                                   QStringList() << QStringLiteral("moc"), parent);
-    generatedFilter->setSourceControlFiles(false);
-    const auto translationFilter = new MSBuildFilter(QStringLiteral("Translation Files"),
-                                                     QStringList() << QStringLiteral("ts"), parent);
-    translationFilter->setParseFiles(false);
-
-    return std::vector<MSBuildFilter *> {
-        sourceFilter, headerFilter, formFilter, resourceFilter, generatedFilter, translationFilter
+    static const std::vector<FilterInfo> INFOS {
+        {QStringLiteral("Source Files"), sourceFileExtensions()},
+        {QStringLiteral("Header Files"), headerFileExtensions()},
+        {QStringLiteral("Form Files"), QStringList() << QStringLiteral("ui")},
+        {QStringLiteral("Resource Files"), QStringList() << QStringLiteral("qrc") << QStringLiteral("rc") << QStringLiteral("*"), false},
+        {QStringLiteral("Generated Files"), QStringList() << QStringLiteral("moc"), true, false},
+        {QStringLiteral("Translation Files"), QStringList() << QStringLiteral("ts"), false},
     };
+
+    return INFOS;
 }
 
-static bool matchesFilter(const MSBuildFilter *filter, const QString &filePath)
+MSBuildFilter * makeBuildFilter(const FilterInfo &filterInfo,
+                               MSBuildItemGroup *itemFiltersGroup)
 {
-    return filter->extensions().contains(QFileInfo(filePath).completeSuffix());
+    const auto filter = new MSBuildFilter(filterInfo.name, filterInfo.extensions, itemFiltersGroup);
+    filter->appendProperty(QStringLiteral("ParseFiles"), filterInfo.parseFiles);
+    filter->appendProperty(QStringLiteral("SourceControlFiles"), filterInfo.sourceControlFiles);
+    return filter;
 }
 
-MSBuildFiltersProject::MSBuildFiltersProject(const GeneratableProductData &product,
-                                             QObject *parent)
-    : MSBuildProject(parent)
+bool matchesFilter(const FilterInfo &filterInfo,
+                   const QString &filePath)
 {
-    // Normally this would be versionInfo.toolsVersion() but for some reason it seems
-    // filters projects are always v4.0
-    setToolsVersion(QStringLiteral("4.0"));
+    return filterInfo.extensions.contains(QFileInfo(filePath).completeSuffix());
+}
 
-    const auto itemGroup = new MSBuildItemGroup(this);
-    const auto filterOptions = defaultItemGroupFilters();
-    for (const auto options : filterOptions) {
-        const auto filter = new MSBuildFilter(options->include(), options->extensions(), itemGroup);
-        filter->appendProperty(QStringLiteral("ParseFiles"), options->parseFiles());
-        filter->appendProperty(QStringLiteral("SourceControlFiles"), options->sourceControlFiles());
-    }
+bool isHeaderFile(const QString &filePath)
+{
+    return headerFileExtensions().contains(QFileInfo(filePath).completeSuffix());
+}
+
+bool isSourceFile(const QString &filePath)
+{
+    return sourceFileExtensions().contains(QFileInfo(filePath).completeSuffix());
+}
+
+MSBuildFileItem * makeFileItem(const QString& filePath,
+                              MSBuildItemGroup *itemGroup)
+{
+    if (isHeaderFile(filePath))
+        return new MSBuildClInclude(itemGroup);
 
+    if (isSourceFile(filePath))
+        return new MSBuildClCompile(itemGroup);
+
+    return new MSBuildNone(itemGroup);
+}
+
+
+class ProductProcessor
+{
+public:
     using StringSet = Internal::Set<QString>;
-    StringSet allFiles;
-    const auto productDatas = product.data.values();
-    for (const auto &productData : productDatas) {
-        for (const auto &groupData : productData.groups())
-            if (groupData.isEnabled())
-                allFiles.unite(Internal::rangeTo<StringSet>(groupData.allFilePaths()));
+
+    ProductProcessor(MSBuildProject *parent)
+        : m_parent(parent)
+        , m_itemFiltersGroup(new MSBuildItemGroup(m_parent))
+    {
     }
 
-    MSBuildItemGroup *headerFilesGroup = nullptr;
-    MSBuildItemGroup *sourceFilesGroup = nullptr;
-    MSBuildItemGroup *filesGroup = nullptr;
-
-    for (const auto &filePath : allFiles) {
-        MSBuildFileItem *fileItem = nullptr;
-
-        for (const MSBuildFilter *options : filterOptions) {
-            if (matchesFilter(options, filePath)) {
-                if (options->include() == QStringLiteral("Header Files")) {
-                    if (!headerFilesGroup)
-                        headerFilesGroup = new MSBuildItemGroup(this);
-                    fileItem = new MSBuildClInclude(headerFilesGroup);
-                } else if (options->include() == QStringLiteral("Source Files")) {
-                    if (!sourceFilesGroup)
-                        sourceFilesGroup = new MSBuildItemGroup(this);
-                    fileItem = new MSBuildClCompile(sourceFilesGroup);
+    void operator()(const QList<ProductData> &productDatas)
+    {
+        for (const auto &productData : productDatas) {
+            auto productName = productData.name();
+
+            for (const auto &groupData : productData.groups()) {
+                if (groupData.name() == productName) {
+                    processProductFiles(Internal::rangeTo<StringSet>(groupData.allFilePaths()));
+                } else {
+                    processGroup(groupData);
                 }
+            }
+        }
+    }
 
-                if (fileItem) {
-                    fileItem->setFilterName(options->include());
-                    break;
+    void processProductFiles(const StringSet &files)
+    {
+        for (const auto &filePath : files) {
+            MSBuildFileItem *fileItem = nullptr;
+
+            for (const auto &filterInfo : getDefaultFilterInfo()) {
+                if (matchesFilter(filterInfo, filePath)) {
+                    makeFilter(filterInfo);
+
+                    if (filterInfo.name == QStringLiteral("Header Files")) {
+                        if (!m_headerFilesGroup)
+                            m_headerFilesGroup = new MSBuildItemGroup(m_parent);
+                        fileItem = new MSBuildClInclude(m_headerFilesGroup);
+                    } else if (filterInfo.name == QStringLiteral("Source Files")) {
+                        if (!m_sourceFilesGroup)
+                            m_sourceFilesGroup = new MSBuildItemGroup(m_parent);
+                        fileItem = new MSBuildClCompile(m_sourceFilesGroup);
+                    }
+
+                    if (fileItem) {
+                        fileItem->setFilterName(filterInfo.name);
+                        break;
+                    }
                 }
             }
+
+            if (!fileItem) {
+                if (!m_filesGroup) {
+                    m_filesGroup = new MSBuildItemGroup(m_parent);
+                }
+
+                fileItem = new MSBuildNone(m_filesGroup);
+            }
+
+            fileItem->setFilePath(filePath);
         }
+    }
 
-        if (!fileItem) {
-            if (!filesGroup)
-                filesGroup = new MSBuildItemGroup(this);
-            fileItem = new MSBuildNone(filesGroup);
+    void processGroup(const GroupData &groupData)
+    {
+        makeFilter({groupData.name(), QStringList() << QStringLiteral("*")});
+
+        auto *itemGroup = new MSBuildItemGroup(m_parent);
+        const auto &files = groupData.allFilePaths();
+        for (const auto &filePath : files) {
+            auto *fileItem = makeFileItem(filePath, itemGroup);
+            fileItem->setFilePath(filePath);
+            fileItem->setFilterName(groupData.name());
         }
-        fileItem->setFilePath(filePath);
     }
 
-    qDeleteAll(filterOptions);
+    void makeFilter(const FilterInfo &filterInfo)
+    {
+        if (!m_createdFilters.contains(filterInfo.name)) {
+            makeBuildFilter(filterInfo, m_itemFiltersGroup);
+            m_createdFilters.insert(filterInfo.name);
+        }
+    }
+
+private:
+    MSBuildProject *m_parent = nullptr;
+    MSBuildItemGroup *m_itemFiltersGroup = nullptr;
+    MSBuildItemGroup *m_headerFilesGroup = nullptr;
+    MSBuildItemGroup *m_sourceFilesGroup = nullptr;
+    MSBuildItemGroup *m_filesGroup = nullptr;
+    QSet<QString> m_createdFilters;
+};
+
+}
+
+MSBuildFiltersProject::MSBuildFiltersProject(const GeneratableProductData &product,
+                                             QObject *parent)
+    : MSBuildProject(parent)
+{
+    // Normally this would be versionInfo.toolsVersion() but for some reason it seems
+    // filters projects are always v4.0
+    setToolsVersion(QStringLiteral("4.0"));
+
+    ProductProcessor(this)(product.data.values());
 }
 
 } // namespace qbs