[clang-tidy] Add '-suppress-checks-filter' option to suppress diagnostics from certain files

[nkakuev]

Summary

Currently clang-tidy doesn't provide a practical way to suppress diagnostics from headers you don't have control over. If using a function defined in such header causes a false positive, there is no easy way to deal with this issue.

Since you cannot modify a header, you cannot add NOLINT (or any other source annotations) to it. And adding NOLINT to each invocation of such function is either impossible or hugely impractical if invocations are ubiquitous.

Using the '-header-filter' doesn't help to address this issue as well. Unless your own headers are strategically named, it is virtually impossible to craft a regex that will filter out only the third-party ones.

The '-line-filter' can be used to suppress such warnings, but it's not very convenient. Instead of excluding a line that produces a warning you have to include all other lines. Plus, it provides no way to suppress only certain warnings from a file.

The option I propose solves aforementioned problems. It allows a user to specify a set of regular expressions to suppress diagnostics from files whose names match these expressions. Additionally, a set of checks can be specified to suppress only certain diagnostics.

The option can be used in the following way:
clang-tidy -suppress-checks-filter='[{"name":"falty_header.h"},{"name":"third-party/","checks":"google-explicit-constructor"}]' source.cpp -- -c

[Eugene.Zelenko]

I think will be good idea to mention this in documentation and release notes.

[alexfh]

What's the biggest complexity with -header-filter? Lack of way to specify <all directories except for these>? Will it help to make -header-filter a GlobList?

[alexfh]

I also don't understand the use case for turning off only some checks for third-party headers. Either you care about third-party stuff or not, why only switch off certain checks?

[nkakuev]

In D26418#590170, @alexfh wrote:

I also don't understand the use case for turning off only some checks for third-party headers. Either you care about third-party stuff or not, why only switch off certain checks?

The use case is ignoring false positives that originate from third-party headers. Because even if you don't care about third-party stuff, you can't suppress all diagnostics from it. Here's an example:

// header.h
void TriggerWarning(const int& In, int& Out) {
  if (In > 123)
    Out = 123;
}

// source.cpp
#include "header.h"
void MaybeInitialize(int &Out) {
  int In;
  TriggerWarning(In, Out);
}

The warning is caused by a third-party code, but header filter won't help you to suppress it since it now relates to your sources.

But let's say this warning is a false-positive. What can you do to suppress it? You can turn off a faulty check, but you need to turn it off for your code.

With '-suppress-checks-filter' you can turn it off for third-party headers only, without sabotaging your own sources.

[nkakuev]

In D26418#590168, @alexfh wrote:

What's the biggest complexity with -header-filter? Lack of way to specify <all directories except for these>? Will it help to make -header-filter a GlobList?

See my previous comment. Header filter isn't going to help when a (false positive) warning, caused by a third-party header, results in diagnostics for your source file.

[malcolm.parsons]

In D26418#590383, @nkakuev wrote:

The warning is caused by a third-party code, but header filter won't help you to suppress it since it now relates to your sources.

The header filter suppresses the warning location, but the note locations are in the main file so they unsuppress the warning.

It sounds like you want note locations to be ignored.

[nkakuev]

In D26418#590417, @malcolm.parsons wrote:

In D26418#590383, @nkakuev wrote:

The warning is caused by a third-party code, but header filter won't help you to suppress it since it now relates to your sources.

The header filter suppresses the warning location, but the note locations are in the main file so they unsuppress the warning.

It sounds like you want note locations to be ignored.

I want a convenient instrument to suppress unwanted diagnostics. Even if I change clang-tidy to ignore note locations, it would still be impractical to use '-header-filter' to exclude diagnostics from certain headers. Header filter was designed to include headers, not to exclude them. Trying to exclude "these m directories and that n files" is close to impossible using a single regular expression. Plus, even if I manage to do this, I'll be ignoring all diagnostics and not only the faulty ones.

Suppress-check-filter is specifically designed to exclude headers and doesn't require abusing regular expressions to do this. Plus, it allows a user to specify what diagnostics he doesn't want, instead of ignoring everything.

[nkakuev]

In D26418#590417, @malcolm.parsons wrote:

In D26418#590383, @nkakuev wrote:

The warning is caused by a third-party code, but header filter won't help you to suppress it since it now relates to your sources.

The header filter suppresses the warning location, but the note locations are in the main file so they unsuppress the warning.

It sounds like you want note locations to be ignored.

On a second thought, ignoring note locations might be a good enough solution for me.
How should I do this? Add a new option (e.g. '-ignore-note-locations')?

[malcolm.parsons]

In D26418#590476, @nkakuev wrote:

On a second thought, ignoring note locations might be a good enough solution for me.
How should I do this? Add a new option (e.g. '-ignore-note-locations')?

I'll let @alexfh decide.

[nkakuev]

Ping.

Ignoring note locations is a coarse-grained solution that will suppress both false and true positives. Suppress-checks-filter is a finer-grained instrument that can be targetted on particular false positives precisely.

My sympathies are with suppress-checks-filter, but if it sounds like too much, I can try to implement note locations ignoring instead.

[alexfh]

Sorry for the delay. I'll try to get back to this patch soon.

[nkakuev]

Ping.

[alexfh]

My apologies again for the delay. There are a few things I'm concerned about:

1. Suppression list being a command-line option is going to be inconvenient to completely useless in many setups. The -line-filter option is special in this regard, since it was added for a rather specific use case - clang-tidy-diff.py. It's impractical to expect a user to specify a long blacklist on the command line, and it seems hacky to introduce a separate wrapper script with an explicit goal to pass this argument to clang-tidy.
2. There are already three mechanisms to filter warnings, introducing another one is going to add more complexity both in the code and in the usage of the tool. We should carefully consider all alternatives before doing so. In particular, if there are important use cases w.r.t. filtering of results clang-tidy doesn't handle well (but should), we could either improve existing suppression mechanisms or delegate warning suppression to an external tool like Code Checker (https://github.com/Ericsson/codechecker).

Going back to the use cases you have:

1. Header files need a different set of checks:

library_a/a.cc:
#include "library_b/b.h"
// <some code that should be clean w.r.t. check1, but may have warnings from check2>
  
library_b/b.h:
// <some code that is not clean w.r.t. check1, but needs to be clean from check2 warnings>

This seems like a natural use case for the .clang-tidy configuration file: one should be able to turn on check1 in library_a/.clang_tidy and check2 in library_b/.clang_tidy and expect to only get corresponding warnings in each of these files. The problem is that it's not implemented that way. Currently the configuration for the main file will be used for all diagnostics generated while analysing the whole translation unit. The checks filter in the configuration file is used for two separate purposes: creating the list of checks to run on each translation unit and filtering diagnostics. We can't use different list of checks for analyzing each header in a single translation unit, but it seems possible to use proper configuration for each header when filtering diagnostics. This way in the example above we would run check1 for the whole TU, but filter out all check1 warnings from library_b/ files. It might even be possible to further improve that to create a union of sets of checks from all headers used by the TU and then filter out irrelevant ones, but it would be a different performance / precision trade-off and it doesn't seem to be necessary at first.

2. Header files should be clean w.r.t. a certain check, but there is a small number of false positives that need to be suppressed without modifying the source code. This seems like a use case of an external suppression list that is best implemented by a stateful tool like Code Checker that stores a database of findings and a suppression list. Alternatively, we could implement a way to read a suppression list from a file (command line doesn't seem to be a good medium for such information) that would ideally be stored and versioned with the code. I believe, it's the same kind of a last resort solution as // NOLINT suppression comments. It's better when each check provides a sane check-specific way to suppress the diagnostic (e.g. like Clang's -Wparentheses warning - https://godbolt.org/g/nVl7we).

3. Warnings in headers that are caused by notes in a different library (what you discuss in https://reviews.llvm.org/D26418#590417). I thought quite a bit about notes in user code unsuppressing warnings in third-party library code back in the time when implementing the corresponding clang-tidy feature, but it turned out to be rather infrequent situation in my setup, so I don't have a strong opinion on how this should be handled. Do you have more motivating examples showing when one would want to disable this feature? (Or am I missing some examples already mentioned in this thread?)

[nkakuev]

Thanks for the response, Alex!

The problem I tried to address in this patch was that notes in source files were "unsuppressing" warnings from third-party headers (this is what we were discussing in https://reviews.llvm.org/D26418#590417). But at this point, I no longer think that my patch is the right way to handle this situation. A general-purpose suppression list looks like a way better idea to me.

As for delegating the suppression of warnings to an external tool, I'm not entirely sure that this is always a good idea. I run clang-tidy on incremental builds on developers machines and use -warnings-as-errors=*. In other words, I treat clang-tidy warnings the same way I treat compiler warnings (with -Werror enabled). A suppression list will let me keep this workflow while using an external tool is likely to break it.

So what do you think about extending existing suppression mechanisms to support suppression lists?

[alexfh]

Adding a mechanism to supply suppression lists would be useful as long as it's flexible and extensible enough and doesn't significantly affect performance (especially, when not in use). In particular, it shouldn't be bound to a specific format or a specific way to store the data (there might be a default format and a default storage schema similar to .clang-tidy configuration files, but it should be easy, for example, to plug a database-backed source of suppression lists). Another important feature is a convenient way to add new suppressions. If you're willing to invest time in designing and implementing this, I'm happy to help with ideas and code reviews.

[• marlowa]

In D26418#653146, @nkakuev wrote:

Ping.

another ping. I am desperate for this enhancement and am really glad that nkakuev has done all the hard development work. I am currently being nobbled in my use of clang-tidy because the project is using Rogue Wave Stingray headers and BCG Control bar headers. Both these components cause loads of clang-tidy issues when the headers get included. This enhancement seems to provide just the mechanism I need.

[• okainov]

Any updates on this one? That sounds so fundamental feature which current version is lacking, it's very frustrating it was not merged yet...

[khoroshansky]

Will this ever be merged?

[• vlebourl]

Very interested in this one as well!

[davidsj2]

I too am interested in this patch. In addition to the use cases already described, this would be helpful for projects that use several different static analysis tools and don't want to clutter code with a bunch of different suppression comments to satisfy each tool.

[aaron.ballman]

While I agree that there's an issue here that needs to be solved, I don't think this patch will be merged as-is -- there are technical issues brought up by @alexfh that have not been addressed, and I share the opinion that we should extend existing suppression mechanisms rather than try to invent another new one. If someone wanted to invest the time and energy into such a patch, I'd be happy to be added as a reviewer.

clang-tidy/ClangTidyDiagnosticConsumer.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
 #include "ClangTidyOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Timer.h"
 
 namespace clang {
 
 class ASTContext;
 class CompilerInstance;
private:
   std::unique_ptr<GlobList> NextGlob;
 };
 
 /// \brief Contains displayed and ignored diagnostic counters for a ClangTidy
 /// run.
 struct ClangTidyStats {
   ClangTidyStats()
       : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
-        ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
+        ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0),
+        ErrorsIgnoredSuppressChecksFilter(0) {}
 
   unsigned ErrorsDisplayed;
   unsigned ErrorsIgnoredCheckFilter;
   unsigned ErrorsIgnoredNOLINT;
   unsigned ErrorsIgnoredNonUserCode;
   unsigned ErrorsIgnoredLineFilter;
+  unsigned ErrorsIgnoredSuppressChecksFilter;
 
   unsigned errorsIgnored() const {
     return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
-           ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
+           ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter +
+           ErrorsIgnoredSuppressChecksFilter;
   }
 };
 
 /// \brief Container for clang-tidy profiling data.
 struct ProfileData {
   llvm::StringMap<llvm::TimeRecord> Records;
 };
 
 /// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
 /// \endcode
 class ClangTidyContext {
 public:
+  /// \brief Collection of pairs that map filenames to suppressed checks.
+  typedef std::vector<std::pair<llvm::Regex, llvm::Optional<GlobList>>>
+      SuppressChecksMap;
+
   /// \brief Initializes \c ClangTidyContext instance.
   ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider);
 
   /// \brief Report any errors detected using this method.
   ///
   /// This is still under heavy development and will likely change towards using
   /// tablegen'd diagnostic IDs.
   /// FIXME: Figure out a way to manage ID spaces.
public:
   /// diagnostic ID.
   StringRef getCheckName(unsigned DiagnosticID) const;
 
   /// \brief Returns check filter for the \c CurrentFile.
   ///
   /// The \c CurrentFile can be changed using \c setCurrentFile.
   GlobList &getChecksFilter();
 
+  /// \brief Returns \c SuppressChecksFilter.
+  SuppressChecksMap &getSuppressChecksFilter();
+
   /// \brief Returns check filter for the \c CurrentFile which
   /// selects checks for upgrade to error.
   GlobList &getWarningAsErrorFilter();
 
   /// \brief Returns global options.
   const ClangTidyGlobalOptions &getGlobalOptions() const;
 
   /// \brief Returns options for \c CurrentFile.
private:
 
   /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
   /// correctly.
   void setDiagnosticsEngine(DiagnosticsEngine *Engine);
 
   /// \brief Store an \p Error.
   void storeError(const ClangTidyError &Error);
 
+  /// \brief Initializes \c SuppressChecksFilter from \c ClangTidyGlobalOptions.
+  void InitializeSuppressChecksFilter();
+
   std::vector<ClangTidyError> Errors;
   DiagnosticsEngine *DiagEngine;
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
   std::unique_ptr<GlobList> CheckFilter;
   std::unique_ptr<GlobList> WarningAsErrorFilter;
 
+  SuppressChecksMap SuppressChecksFilter;
+
   LangOptions LangOpts;
 
   ClangTidyStats Stats;
 
   std::string CurrentBuildDirectory;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 
private:
   /// context.
   llvm::Regex *getHeaderFilter();
 
   /// \brief Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
   /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
+  /// \brief Returns true if diagnostic \c Info is matched by \c
+  /// SuppressChecksFilter.
+  bool diagnosticMatchesSuppressChecksFilter(const Diagnostic &Info) const;
+
   ClangTidyContext &Context;
   std::unique_ptr<DiagnosticsEngine> Diags;
   SmallVector<ClangTidyError, 8> Errors;
   std::unique_ptr<llvm::Regex> HeaderFilter;
   bool LastErrorRelatesToUserCode;
   bool LastErrorPassesLineFilter;
   bool LastErrorWasIgnored;
 };
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H

clang-tidy/ClangTidyDiagnosticConsumer.cpp

 
 ClangTidyContext::ClangTidyContext(
     std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider)
     : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
       Profile(nullptr) {
   // Before the first translation unit we can get errors related to command-line
   // parsing, use empty string for the file name in this case.
   setCurrentFile("");
+  InitializeSuppressChecksFilter();
 }
 
 DiagnosticBuilder ClangTidyContext::diag(
     StringRef CheckName, SourceLocation Loc, StringRef Description,
     DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
   assert(Loc.isValid());
   unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
       Level, (Description + " [" + CheckName + "]").str());

 
 void ClangTidyContext::setCheckProfileData(ProfileData *P) { Profile = P; }
 
 GlobList &ClangTidyContext::getChecksFilter() {
   assert(CheckFilter != nullptr);
   return *CheckFilter;
 }
 
+ClangTidyContext::SuppressChecksMap &
+ClangTidyContext::getSuppressChecksFilter() {
+  return SuppressChecksFilter;
+};
+
 GlobList &ClangTidyContext::getWarningAsErrorFilter() {
   assert(WarningAsErrorFilter != nullptr);
   return *WarningAsErrorFilter;
 }
 
 /// \brief Store a \c ClangTidyError.
 void ClangTidyContext::storeError(const ClangTidyError &Error) {
   Errors.push_back(Error);
 }
 
+void ClangTidyContext::InitializeSuppressChecksFilter() {
+  for (const SuppressChecksFilterEntry &Entry :
+       getGlobalOptions().SuppressChecksFilter)
+    SuppressChecksFilter.emplace_back(llvm::Regex(Entry.FileNameRegex),
+                                      Entry.Checks.empty()
+                                          ? llvm::Optional<GlobList>()
+                                          : GlobList(Entry.Checks));
+}
+
 StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
   llvm::DenseMap<unsigned, std::string>::const_iterator I =
       CheckNamesByDiagnosticID.find(DiagnosticID);
   if (I != CheckNamesByDiagnosticID.end())
     return I->second;
   return "";
 }
 

 }
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
     return;
 
   if (Info.getLocation().isValid() && DiagLevel != DiagnosticsEngine::Error &&
-      DiagLevel != DiagnosticsEngine::Fatal &&
-      LineIsMarkedWithNOLINTinMacro(Diags->getSourceManager(),
+      DiagLevel != DiagnosticsEngine::Fatal) {
+    if (LineIsMarkedWithNOLINTinMacro(Diags->getSourceManager(),
                                       Info.getLocation())) {
       ++Context.Stats.ErrorsIgnoredNOLINT;
       // Ignored a warning, should ignore related notes as well
       LastErrorWasIgnored = true;
       return;
     }
 
+    if (diagnosticMatchesSuppressChecksFilter(Info)) {
+      ++Context.Stats.ErrorsIgnoredSuppressChecksFilter;
+      LastErrorWasIgnored = true;
+      return;
+    }
+  }
+
   LastErrorWasIgnored = false;
   // Count warnings/errors.
   DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
 
   if (DiagLevel == DiagnosticsEngine::Note) {
     assert(!Errors.empty() &&
            "A diagnostic note can only be appended to a message.");
   } else {
if (FileName.endswith(Filter.Name)) {
           return true;
       }
       return false;
     }
   }
   return false;
 }
 
+bool ClangTidyDiagnosticConsumer::diagnosticMatchesSuppressChecksFilter(
+    const Diagnostic &Info) const {
+  const SourceLocation &Location = Info.getLocation();
+  if (!Location.isValid() || !Location.isFileID() || !Info.hasSourceManager())
+    return false;
+
+  const SourceManager &SourceManager = Info.getSourceManager();
+  const StringRef FileName = SourceManager.getFilename(Location);
+  const StringRef CheckName = Context.getCheckName(Info.getID());
+
+  for (std::pair<llvm::Regex, llvm::Optional<GlobList>> &Entry :
+       Context.getSuppressChecksFilter()) {
+    if (Entry.first.match(FileName)) {
+      llvm::Optional<GlobList> &Checks = Entry.second;
+      if (!Checks.hasValue() || Checks.getValue().contains(CheckName))
+        return true;
+    }
+  }
+
+  return false;
+}
+
 void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location) {
   // Invalid location may mean a diagnostic in a command line, don't skip these.
   if (!Location.isValid()) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }
 

clang-tidy/ClangTidyOptions.h

struct FileFilter {
 
   /// \brief LineRange is a pair<start, end> (inclusive).
   typedef std::pair<unsigned, unsigned> LineRange;
 
   /// \brief A list of line ranges in this file, for which we show warnings.
   std::vector<LineRange> LineRanges;
 };
 
+/// \brief If a file name matches \c FileNameRegex, checks listed in \c Checks
+/// will be suppressed.
+struct SuppressChecksFilterEntry {
+  /// \brief File name pattern.
+  std::string FileNameRegex;
+
+  /// \brief List of checks to suppress.
+  std::string Checks;
+};
+
 /// \brief Global options. These options are neither stored nor read from
 /// configuration files.
 struct ClangTidyGlobalOptions {
   /// \brief Output warnings from certain line ranges of certain files only.
   /// If empty, no warnings will be filtered.
   std::vector<FileFilter> LineFilter;
+
+  /// \brief Suppress warnings from certain checks if a file name matches a
+  /// pattern. If no checks are specified, all warnings from a file will be
+  /// suppressed.
+  std::vector<SuppressChecksFilterEntry> SuppressChecksFilter;
 };
 
 /// \brief Contains options for clang-tidy. These options may be read from
 /// configuration files, and may be different for different translation units.
 struct ClangTidyOptions {
   /// \brief These options are used for all settings that haven't been
   /// overridden by the \c OptionsProvider.
   ///
protected:
   ClangTidyOptions OverrideOptions;
   ConfigFileHandlers ConfigHandlers;
 };
 
 /// \brief Parses LineFilter from JSON and stores it to the \p Options.
 std::error_code parseLineFilter(llvm::StringRef LineFilter,
                                 ClangTidyGlobalOptions &Options);
 
+/// \brief Parses SuppressChecksFilter from JSON and stores it to the \p
+/// Options.
+std::error_code parseSuppressChecksFilter(llvm::StringRef SuppressChecksFilter,
+                                          ClangTidyGlobalOptions &Options);
+
 /// \brief Parses configuration from JSON and returns \c ClangTidyOptions or an
 /// error.
 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(llvm::StringRef Config);
 
 /// \brief Serializes configuration to a YAML-encoded string.
 std::string configurationAsText(const ClangTidyOptions &Options);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H

clang-tidy/ClangTidyOptions.cpp

 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
 #define DEBUG_TYPE "clang-tidy-options"
 
 using clang::tidy::ClangTidyOptions;
 using clang::tidy::FileFilter;
+using clang::tidy::SuppressChecksFilterEntry;
 using OptionsSource = clang::tidy::ClangTidyOptionsProvider::OptionsSource;
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
+LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(SuppressChecksFilterEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(ClangTidyOptions::StringPair)
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
 
 namespace llvm {
 namespace yaml {
 
 // Map std::pair<int, int> to a JSON array of size 2.
 template <> struct SequenceTraits<FileFilter::LineRange> {
static StringRef validate(IO &io, FileFilter &File) {
     for (const FileFilter::LineRange &Range : File.LineRanges) {
       if (Range.first <= 0 || Range.second <= 0)
         return "Invalid line range";
     }
     return StringRef();
   }
 };
 
+template <> struct MappingTraits<SuppressChecksFilterEntry> {
+  static void mapping(IO &IO, SuppressChecksFilterEntry &Filter) {
+    IO.mapRequired("name", Filter.FileNameRegex);
+    IO.mapOptional("checks", Filter.Checks);
+  }
+  static StringRef validate(IO &io, SuppressChecksFilterEntry &Filter) {
+    if (Filter.FileNameRegex.empty())
+      return "No file name pattern specified";
+    return StringRef();
+  }
+};
+
 template <> struct MappingTraits<ClangTidyOptions::StringPair> {
   static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue) {
     IO.mapRequired("key", KeyValue.first);
     IO.mapRequired("value", KeyValue.second);
   }
 };
 
 struct NOptionMap {

 /// \brief Parses -line-filter option and stores it to the \c Options.
 std::error_code parseLineFilter(StringRef LineFilter,
                                 clang::tidy::ClangTidyGlobalOptions &Options) {
   llvm::yaml::Input Input(LineFilter);
   Input >> Options.LineFilter;
   return Input.error();
 }
 
+/// \brief Parses -suppress-checks-filter option and stores it to the \c
+/// Options.
+std::error_code
+parseSuppressChecksFilter(StringRef SuppressChecksFilter,
+                          clang::tidy::ClangTidyGlobalOptions &Options) {
+  llvm::yaml::Input Input(SuppressChecksFilter);
+  Input >> Options.SuppressChecksFilter;
+  return Input.error();
+}
+
 llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
   llvm::yaml::Input Input(Config);
   ClangTidyOptions Options;
   Input >> Options;
   if (Input.error())
     return Input.error();
   return Options;
 }

clang-tidy/tool/ClangTidyMain.cpp

JSON array of objects:
   [
     {"name":"file1.cpp","lines":[[1,3],[5,7]]},
     {"name":"file2.h"}
   ]
 )"),
                                        cl::init(""),
                                        cl::cat(ClangTidyCategory));
 
+static cl::opt<std::string>
+    SuppressWarningsFromHeaders("suppress-checks-filter", cl::desc(R"(
+Suppress diagnostics from files whose names match
+provided regular expression. If a list of checks
+is specified, only diagnostics produces by these
+checks will be suppressed. The format of
+the argument is a JSON array of objects:
+[
+  {"name":"header1.h","checks":"boost-*,cert-*"},
+  {"name":"header2.h"}
+]
+)"),
+                                cl::init(""), cl::cat(ClangTidyCategory));
+
 static cl::opt<bool> Fix("fix", cl::desc(R"(
 Apply suggested fixes. Without -fix-errors
 clang-tidy will bail out if any compilation
 errors were found.
 )"),
                          cl::init(false), cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> FixErrors("fix-errors", cl::desc(R"(
if (Stats.ErrorsIgnoredLineFilter) {
       llvm::errs() << Separator << Stats.ErrorsIgnoredLineFilter
                    << " due to line filter";
       Separator = ", ";
     }
     if (Stats.ErrorsIgnoredNOLINT) {
       llvm::errs() << Separator << Stats.ErrorsIgnoredNOLINT << " NOLINT";
       Separator = ", ";
     }
-    if (Stats.ErrorsIgnoredCheckFilter)
+    if (Stats.ErrorsIgnoredCheckFilter) {
       llvm::errs() << Separator << Stats.ErrorsIgnoredCheckFilter
                    << " with check filters";
+      Separator = ", ";
+    }
+    if (Stats.ErrorsIgnoredSuppressChecksFilter)
+      llvm::errs() << Separator << Stats.ErrorsIgnoredSuppressChecksFilter
+                   << " with suppressed checks filters";
     llvm::errs() << ").\n";
     if (Stats.ErrorsIgnoredNonUserCode)
       llvm::errs() << "Use -header-filter=.* to display errors from all "
                       "non-system headers. Use -system-headers to display "
                       "errors from system headers as well.\n";
   }
 }
 
static void printProfileData(const ProfileData &Profile,
   Total.print(Total, OS);
   OS << "Total\n";
   OS << Line << "\n";
   OS.flush();
 }
 
 static std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider() {
   ClangTidyGlobalOptions GlobalOptions;
+  bool ArgumentsAreValid = true;
   if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
-    llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
+    llvm::errs() << "Invalid LineFilter: " << Err.message();
+    ArgumentsAreValid = false;
+  }
+
+  if (std::error_code Err = parseSuppressChecksFilter(
+          SuppressWarningsFromHeaders, GlobalOptions)) {
+    llvm::errs() << "Cannot parse '-suppress-checks-filter': "
+                 << Err.message();
+    ArgumentsAreValid = false;
+  }
+
+  if (!ArgumentsAreValid) {
+    llvm::errs() << "\n\nUsage:\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return nullptr;
   }
 
   ClangTidyOptions DefaultOptions;
   DefaultOptions.Checks = DefaultChecks;
   DefaultOptions.WarningsAsErrors = "";
   DefaultOptions.HeaderFilterRegex = HeaderFilter;

test/clang-tidy/Inputs/suppress-checks-filter/1/header1.h

+class A1 { A1(int); };
+

test/clang-tidy/Inputs/suppress-checks-filter/1/header2.h

+class A2 { A2(int); };
+
+class B2 {
+  B2(int &In, int &Out) { Out = (int)In; }
+};
+

test/clang-tidy/Inputs/suppress-checks-filter/2/header3.h

+class A3 { A3(int); };
+

test/clang-tidy/Inputs/suppress-checks-filter/2/header4.h

+class A4 { A4(int); };
+

test/clang-tidy/suppress-checks-filter.cpp

+// RUN: clang-tidy -checks='-*,google-explicit-constructor,google-readability-casting' -header-filter='header*' -suppress-checks-filter='[{"name":"header1.h"},{"name":"header2.h","checks":"google-explicit-constructor"},{"name":"2/"}]' %s -- -I %S/Inputs/suppress-checks-filter 2>&1 | FileCheck %s
+
+#include "1/header1.h"
+// CHECK-NOT: header1.h:{{.*}} warning
+
+#include "1/header2.h"
+// CHECK-NOT: 1/header2.h:{{.*}} warning: single-argument constructors {{.*}}
+// CHECK: 1/header2.h:{{.*}} warning: redundant cast to the same type {{.*}}
+
+#include "2/header3.h"
+// CHECK-NOT: 2/header3.h:{{.*}} warning: single-argument constructors
+
+#include "2/header4.h"
+// CHECK-NOT: 2/header4.h:{{.*}} warning: single-argument constructors
+
+// CHECK: Suppressed 4 warnings (4 with suppressed checks filters)
+