cppeditor: make it possible to ignore patterns

Allows the user to ignore certain patterns so that these files wont
be indexed

Fixes: QTCREATORBUG-28313
Change-Id: I2a860a473ca1a267e9fab31436fc98b8f4004484
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/cppeditor/cppcodemodelsettings.cpp

@@ -45,6 +45,12 @@ static QString interpretAmbiguousHeadersAsCHeadersKey()
 static QString skipIndexingBigFilesKey()
 { return QLatin1String(Constants::CPPEDITOR_SKIP_INDEXING_BIG_FILES); }
 
+static QString ignoreFilesKey()
+{ return QLatin1String(Constants::CPPEDITOR_IGNORE_FILES); }
+
+static QString ignorePatternKey()
+{ return QLatin1String(Constants::CPPEDITOR_IGNORE_PATTERN); }
+
 static QString useBuiltinPreprocessorKey()
 { return QLatin1String(Constants::CPPEDITOR_USE_BUILTIN_PREPROCESSOR); }
 
@@ -91,6 +97,12 @@ void CppCodeModelSettings::fromSettings(QSettings *s)
     const QVariant skipIndexingBigFiles = s->value(skipIndexingBigFilesKey(), true);
     setSkipIndexingBigFiles(skipIndexingBigFiles.toBool());
 
+    const QVariant ignoreFiles = s->value(ignoreFilesKey(), false);
+    setIgnoreFiles(ignoreFiles.toBool());
+
+    const QVariant ignorePattern = s->value(ignorePatternKey(), "");
+    setIgnorePattern(ignorePattern.toString());
+
     setUseBuiltinPreprocessor(s->value(useBuiltinPreprocessorKey(), true).toBool());
 
     const QVariant indexerFileSizeLimit = s->value(indexerFileSizeLimitKey(), 5);
@@ -110,6 +122,8 @@ void CppCodeModelSettings::toSettings(QSettings *s)
 
     s->setValue(interpretAmbiguousHeadersAsCHeadersKey(), interpretAmbigiousHeadersAsCHeaders());
     s->setValue(skipIndexingBigFilesKey(), skipIndexingBigFiles());
+    s->setValue(ignoreFilesKey(), ignoreFiles());
+    s->setValue(ignorePatternKey(), QVariant(ignorePattern()));
     s->setValue(useBuiltinPreprocessorKey(), useBuiltinPreprocessor());
     s->setValue(indexerFileSizeLimitKey(), indexerFileSizeLimitInMb());
 
@@ -158,6 +172,27 @@ void CppCodeModelSettings::setIndexerFileSizeLimitInMb(int sizeInMB)
     m_indexerFileSizeLimitInMB = sizeInMB;
 }
 
+bool CppCodeModelSettings::ignoreFiles() const
+{
+   return m_ignoreFiles;
+}
+
+void CppCodeModelSettings::setIgnoreFiles(bool ignoreFiles)
+{
+    m_ignoreFiles = ignoreFiles;
+}
+
+QString CppCodeModelSettings::ignorePattern() const
+{
+   return m_ignorePattern;
+}
+
+void CppCodeModelSettings::setIgnorePattern(const QString& ignorePattern)
+{
+    m_ignorePattern = ignorePattern;
+}
+
+
 bool CppCodeModelSettings::enableLowerClazyLevels() const
 {
     return m_enableLowerClazyLevels;

src/plugins/cppeditor/cppcodemodelsettings.h

@@ -57,6 +57,11 @@ public:
     void setCategorizeFindReferences(bool categorize) { m_categorizeFindReferences = categorize; }
     bool categorizeFindReferences() const { return m_categorizeFindReferences; }
 
+    bool ignoreFiles() const;
+    void setIgnoreFiles(bool ignoreFiles);
+    QString ignorePattern() const;
+    void setIgnorePattern(const QString& ignorePattern);
+
 signals:
     void clangDiagnosticConfigsInvalidated(const QVector<Utils::Id> &configId);
     void changed();
@@ -69,6 +74,8 @@ private:
     int m_indexerFileSizeLimitInMB = 5;
     bool m_enableLowerClazyLevels = true; // For UI behavior only
     bool m_categorizeFindReferences = false; // Ephemeral!
+    bool m_ignoreFiles = false;
+    QString m_ignorePattern;
 };
 
 class CPPEDITOR_EXPORT ClangdSettings : public QObject

src/plugins/cppeditor/cppcodemodelsettingspage.cpp

@@ -31,6 +31,7 @@
 #include <QTextStream>
 #include <QVBoxLayout>
 #include <QVersionNumber>
+#include <QTextBlock>
 
 #include <limits>
 
@@ -54,6 +55,8 @@ private:
     QCheckBox *m_useBuiltinPreprocessorCheckBox;
     QCheckBox *m_skipIndexingBigFilesCheckBox;
     QSpinBox *m_bigFilesLimitSpinBox;
+    QCheckBox *m_ignoreFilesCheckBox;
+    QPlainTextEdit *m_ignorePatternTextEdit;
 };
 
 CppCodeModelSettingsWidget::CppCodeModelSettingsWidget(CppCodeModelSettings *s)
@@ -70,6 +73,19 @@ CppCodeModelSettingsWidget::CppCodeModelSettingsWidget(CppCodeModelSettings *s)
     m_bigFilesLimitSpinBox->setRange(1, 500);
     m_bigFilesLimitSpinBox->setValue(m_settings->indexerFileSizeLimitInMb());
 
+    m_ignoreFilesCheckBox = new QCheckBox(tr("Ignore files"));
+    m_ignoreFilesCheckBox->setToolTip(tr(
+        "<html><head/><body><p>Ignore files that match these wildcard patterns, one wildcard per line.</p></body></html>"));
+
+    m_ignoreFilesCheckBox->setChecked(m_settings->ignoreFiles());
+    m_ignorePatternTextEdit = new QPlainTextEdit(m_settings->ignorePattern());
+    m_ignorePatternTextEdit->setToolTip(m_ignoreFilesCheckBox->toolTip());
+    m_ignorePatternTextEdit->setEnabled(m_ignoreFilesCheckBox->isChecked());
+
+    connect(m_ignoreFilesCheckBox, &QCheckBox::stateChanged, [this] {
+       m_ignorePatternTextEdit->setEnabled(m_ignoreFilesCheckBox->isChecked());
+    });
+
     m_ignorePchCheckBox = new QCheckBox(tr("Ignore precompiled headers"));
     m_ignorePchCheckBox->setToolTip(tr(
         "<html><head/><body><p>When precompiled headers are not ignored, the parsing for code "
@@ -98,6 +114,7 @@ CppCodeModelSettingsWidget::CppCodeModelSettingsWidget(CppCodeModelSettings *s)
                 m_ignorePchCheckBox,
                 m_useBuiltinPreprocessorCheckBox,
                 Row { m_skipIndexingBigFilesCheckBox, m_bigFilesLimitSpinBox, st },
+                Row { Column { m_ignoreFilesCheckBox, st }, m_ignorePatternTextEdit },
             }
         },
         st
@@ -132,6 +149,16 @@ bool CppCodeModelSettingsWidget::applyGeneralWidgetsToSettings() const
         m_settings->setUseBuiltinPreprocessor(newUseBuiltinPreprocessor);
         settingsChanged = true;
     }
+    const bool ignoreFiles = m_ignoreFilesCheckBox->isChecked();
+    if (m_settings->ignoreFiles() != ignoreFiles) {
+        m_settings->setIgnoreFiles(ignoreFiles);
+        settingsChanged = true;
+    }
+    const QString ignorePattern = m_ignorePatternTextEdit->toPlainText();
+    if (m_settings->ignorePattern() != ignorePattern) {
+        m_settings->setIgnorePattern(ignorePattern);
+        settingsChanged = true;
+    }
     const int newFileSizeLimit = m_bigFilesLimitSpinBox->value();
     if (m_settings->indexerFileSizeLimitInMb() != newFileSizeLimit) {
         m_settings->setIndexerFileSizeLimitInMb(newFileSizeLimit);

src/plugins/cppeditor/cppeditorconstants.h

@@ -89,6 +89,8 @@ const char CPPEDITOR_INTERPRET_AMBIGIUOUS_HEADERS_AS_C_HEADERS[]
 const char CPPEDITOR_USE_BUILTIN_PREPROCESSOR[] = "UseBuiltinPreprocessor";
 const char CPPEDITOR_SKIP_INDEXING_BIG_FILES[] = "SkipIndexingBigFiles";
 const char CPPEDITOR_INDEXER_FILE_SIZE_LIMIT[] = "IndexerFileSizeLimit";
+const char CPPEDITOR_IGNORE_FILES[] = "IgnoreFiles";
+const char CPPEDITOR_IGNORE_PATTERN[] = "IgnorePattern";
 
 const char CPP_CLANG_DIAG_CONFIG_QUESTIONABLE[] = "Builtin.Questionable";
 const char CPP_CLANG_DIAG_CONFIG_BUILDSYSTEM[] = "Builtin.BuildSystem";

src/plugins/cppeditor/cppmodelmanager.cpp

@@ -69,6 +69,8 @@
 #include <QMutexLocker>
 #include <QReadLocker>
 #include <QReadWriteLock>
+#include <QRegularExpression>
+#include <QRegularExpressionMatch>
 #include <QTextBlock>
 #include <QThreadPool>
 #include <QTimer>
@@ -1050,19 +1052,44 @@ CppLocatorData *CppModelManager::locatorData() const
     return &d->m_locatorData;
 }
 
-static QSet<QString> tooBigFilesRemoved(const QSet<QString> &files, int fileSizeLimitInMb)
+static QSet<QString> filteredFilesRemoved(const QSet<QString> &files, int fileSizeLimitInMb,
+                                          bool ignoreFiles,
+                                          const QString& ignorePattern)
 {
-    if (fileSizeLimitInMb <= 0)
+    if (fileSizeLimitInMb <= 0 && !ignoreFiles)
         return files;
 
     QSet<QString> result;
     QFileInfo fileInfo;
+    QList<QRegularExpression> regexes;
+    const QStringList wildcards = ignorePattern.split('\n');
+
+    for (const QString &wildcard : wildcards)
+        regexes.append(QRegularExpression::fromWildcard(wildcard, Qt::CaseInsensitive,
+                                                        QRegularExpression::UnanchoredWildcardConversion));
 
     for (const QString &filePath : files) {
         fileInfo.setFile(filePath);
-        if (fileSizeExceedsLimit(fileInfo, fileSizeLimitInMb))
+        if (fileSizeLimitInMb > 0 && fileSizeExceedsLimit(fileInfo, fileSizeLimitInMb))
             continue;
+        bool skip = false;
+        if (ignoreFiles) {
+            for (const QRegularExpression &rx: std::as_const(regexes)) {
+                QRegularExpressionMatch match = rx.match(fileInfo.absoluteFilePath());
+                if (match.hasMatch()) {
+                    const QString msg = QCoreApplication::translate(
+                                "CppIndexer",
+                                "C++ Indexer: Skipping file \"%1\" because its path matches the ignore pattern.")
+                                    .arg(filePath);
+                    QMetaObject::invokeMethod(Core::MessageManager::instance(),
+                                              [msg]() { Core::MessageManager::writeSilently(msg); });
+                    skip = true;
+                    break;
+                }
+            }
+        }
 
+        if (!skip)
             result << filePath;
     }
 
@@ -1075,7 +1102,9 @@ QFuture<void> CppModelManager::updateSourceFiles(const QSet<QString> &sourceFile
     if (sourceFiles.isEmpty() || !d->m_indexerEnabled)
         return QFuture<void>();
 
-    const QSet<QString> filteredFiles = tooBigFilesRemoved(sourceFiles, indexerFileSizeLimitInMb());
+    const QSet<QString> filteredFiles = filteredFilesRemoved(sourceFiles, indexerFileSizeLimitInMb(),
+                                                             codeModelSettings()->ignoreFiles(),
+                                                             codeModelSettings()->ignorePattern());
 
     return d->m_internalIndexingSupport->refreshSourceFiles(filteredFiles, mode);
 }