[clang-tidy] Add a SuppressedChecks option to ignore diagnostics from specific checks

[carlosgalvezp]

Could you summarize what problem this is solving? There's multiple ways to "ignore diagnostics from specific checks", I think it would be confusing to add yet another one.

[reyg]

I actually couldn't find a way to black-list specific checks. Is there a way to do that?

[carlosgalvezp]

In D116163#3206473, @reyg wrote:

I actually couldn't find a way to black-list specific checks. Is there a way to do that?

Just prepend a dash to the check name that you want to disable:

checks=cppcoreguidelines-*,-cppcoreguidelines-pro-type-pointer-arithmetic

This will enable all checks from cppcoreguidelines except cppcoreguidelines-pro-type-pointer-arithmetic.

Normally you do this with pretty formatting in the .clang-tidy file:

Checks: > 
    cppcoreguidelines-*,
    -cppcoreguidelines-pro-type-pointer-arithmetic,
    -cppcoreguidelines-avoid-c-arrays,

[reyg]

Well now I feel stupid for not realizing that, thanks for pointing it out :)

At least I learned how to hack around in clang-tidy 😄

[carlosgalvezp]

No worries, it's indeed good practice! Feel free to take a look at the docs, where this (and many more features) is described :)
https://clang.llvm.org/extra/clang-tidy/

will disable all default checks (-*) and enable all clang-analyzer-* checks except for clang-analyzer-cplusplus* ones.

And of course if you think something is unclear feel free to improve it :)

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

private:
 
   DiagnosticsEngine *DiagEngine;
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
 
   std::unique_ptr<CachedGlobList> CheckFilter;
+  std::unique_ptr<CachedGlobList> SuppressedCheckFilter;
   std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
 
   LangOptions LangOpts;
 
   ClangTidyStats Stats;
 
   std::string CurrentBuildDirectory;
 

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }
 
 void ClangTidyContext::setCurrentFile(StringRef File) {
   CurrentFile = std::string(File);
   CurrentOptions = getOptionsForFile(CurrentFile);
   CheckFilter = std::make_unique<CachedGlobList>(*getOptions().Checks);
+  SuppressedCheckFilter =
+      std::make_unique<CachedGlobList>(*getOptions().SuppressedChecks);
   WarningAsErrorFilter =
       std::make_unique<CachedGlobList>(*getOptions().WarningsAsErrors);
 }
 
 void ClangTidyContext::setASTContext(ASTContext *Context) {
   DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
   LangOpts = Context->getLangOpts();
 }
ClangTidyContext::getProfileStorageParams() const {
   if (ProfilePrefix.empty())
     return llvm::None;
 
   return ClangTidyProfiling::StorageParams(ProfilePrefix, CurrentFile);
 }
 
 bool ClangTidyContext::isCheckEnabled(StringRef CheckName) const {
   assert(CheckFilter != nullptr);
-  return CheckFilter->contains(CheckName);
+  assert(SuppressedCheckFilter != nullptr);
+  return CheckFilter->contains(CheckName) &&
+         !SuppressedCheckFilter->contains(CheckName);
 }
 
 bool ClangTidyContext::treatAsError(StringRef CheckName) const {
   assert(WarningAsErrorFilter != nullptr);
   return WarningAsErrorFilter->contains(CheckName);
 }
 
 std::string ClangTidyContext::getCheckName(unsigned DiagnosticID) const {

clang-tools-extra/clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
   /// of this instance overridden by the fields of \p Other that have a value.
   /// \p Order specifies precedence of \p Other option.
   LLVM_NODISCARD ClangTidyOptions merge(const ClangTidyOptions &Other,
                                         unsigned Order) const;
 
   /// Checks filter.
   llvm::Optional<std::string> Checks;
 
+  /// Suppressed checks filter.
+  llvm::Optional<std::string> SuppressedChecks;
+
   /// WarningsAsErrors filter.
   llvm::Optional<std::string> WarningsAsErrors;
 
   /// Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   llvm::Optional<std::string> HeaderFilterRegex;
 
   /// Output warnings from system headers matching \c HeaderFilterRegex.

clang-tools-extra/clang-tidy/ClangTidyOptions.cpp

 };
 
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
         IO, Options.CheckOptions);
     bool Ignored = false;
     IO.mapOptional("Checks", Options.Checks);
+    IO.mapOptional("SuppressedChecks", Options.SuppressedChecks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
     IO.mapOptional("AnalyzeTemporaryDtors", Ignored); // legacy compatibility
     IO.mapOptional("FormatStyle", Options.FormatStyle);
     IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", NOpts->Options);
     IO.mapOptional("ExtraArgs", Options.ExtraArgs);
     IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
     IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
     IO.mapOptional("UseColor", Options.UseColor);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
 ClangTidyOptions ClangTidyOptions::getDefaults() {
   ClangTidyOptions Options;
   Options.Checks = "";
+  Options.SuppressedChecks = "";
   Options.WarningsAsErrors = "";
   Options.HeaderFilterRegex = "";
   Options.SystemHeaders = false;
   Options.FormatStyle = "none";
   Options.User = llvm::None;
   for (const ClangTidyModuleRegistry::entry &Module :
        ClangTidyModuleRegistry::entries())
     Options.mergeWith(Module.instantiate()->getModuleOptions(), 0);

 static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
   if (Src)
     Dest = Src;
 }
 
 ClangTidyOptions &ClangTidyOptions::mergeWith(const ClangTidyOptions &Other,
                                               unsigned Order) {
   mergeCommaSeparatedLists(Checks, Other.Checks);
+  mergeCommaSeparatedLists(SuppressedChecks, Other.SuppressedChecks);
   mergeCommaSeparatedLists(WarningsAsErrors, Other.WarningsAsErrors);
   overrideValue(HeaderFilterRegex, Other.HeaderFilterRegex);
   overrideValue(SystemHeaders, Other.SystemHeaders);
   overrideValue(FormatStyle, Other.FormatStyle);
   overrideValue(User, Other.User);
   overrideValue(UseColor, Other.UseColor);
   mergeVectors(ExtraArgs, Other.ExtraArgs);
   mergeVectors(ExtraArgsBefore, Other.ExtraArgsBefore);

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

static std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider(
   if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return nullptr;
   }
 
   ClangTidyOptions DefaultOptions;
   DefaultOptions.Checks = DefaultChecks;
+  DefaultOptions.SuppressedChecks = "";
   DefaultOptions.WarningsAsErrors = "";
   DefaultOptions.HeaderFilterRegex = HeaderFilter;
   DefaultOptions.SystemHeaders = SystemHeaders;
   DefaultOptions.FormatStyle = FormatStyle;
   DefaultOptions.User = llvm::sys::Process::GetEnv("USER");
   // USERNAME is used on Windows.
   if (!DefaultOptions.User)
     DefaultOptions.User = llvm::sys::Process::GetEnv("USERNAME");

clang-tools-extra/unittests/clang-tidy/ClangTidyDiagnosticConsumerTest.cpp

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
     const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var");
     // Add diagnostics in the wrong order.
     diag(Var->getLocation(), "variable");
     diag(Var->getTypeSpecStartLoc(), "type specifier");
   }
 };
 
+// Test that has name == "test-check-noisy" and outputs exactly one diagnostic.
+class NoisyCheck : public ClangTidyCheck {
+public:
+  NoisyCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck("test-check-noisy", Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override {
+    Finder->addMatcher(ast_matchers::varDecl().bind("var"), this);
+  }
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
+    diag("Some diagnostic");
+  }
+};
+
 class HighlightTestCheck : public ClangTidyCheck {
 public:
   HighlightTestCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
     Finder->addMatcher(ast_matchers::varDecl().bind("var"), this);
   }
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override {
TEST(ClangTidyDiagnosticConsumer, SortsErrors) {
   std::vector<ClangTidyError> Errors;
   runCheckOnCode<TestCheck>("int a;", &Errors);
   EXPECT_EQ(3ul, Errors.size());
   EXPECT_EQ("DiagWithNoLoc", Errors[0].Message.Message);
   EXPECT_EQ("type specifier", Errors[1].Message.Message);
   EXPECT_EQ("variable", Errors[2].Message.Message);
 }
 
+TEST(ClangTidyDiagnosticConsumer, SkipsSuppressedChecks) {
+  std::vector<ClangTidyError> Errors;
+  ClangTidyOptions CustomOptions;
+  CustomOptions.SuppressedChecks = "*noisy*";
+  runCheckOnCode<TestCheck, NoisyCheck>("int a;", &Errors, "input.cc", None,
+                                        CustomOptions);
+  // 4 comming from TestCheck, 0 from NoisyCheck (since it's suppressed).
+  EXPECT_EQ(3ul, Errors.size());
+}
+
+TEST(ClangTidyDiagnosticConsumer, ChecksIfNotSuppressed) {
+  std::vector<ClangTidyError> Errors;
+  ClangTidyOptions CustomOptions;
+  CustomOptions.SuppressedChecks = "*different_glob*";
+  runCheckOnCode<TestCheck, NoisyCheck>("int a;", &Errors, "input.cc", None,
+                                        CustomOptions);
+
+  // 4 comming from TestCheck, 1 from NoisyCheck.
+  EXPECT_EQ(4ul, Errors.size());
+}
+
 TEST(ClangTidyDiagnosticConsumer, HandlesSourceRangeHighlight) {
   std::vector<ClangTidyError> Errors;
   runCheckOnCode<HighlightTestCheck>("int abc;", &Errors);
   EXPECT_EQ(1ul, Errors.size());
   EXPECT_EQ("highlight range", Errors[0].Message.Message);
 
   // int abc;
   // ____^

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp

TEST(ParseLineFilter, ValidFilter) {
   EXPECT_EQ(1u, Options.LineFilter[2].LineRanges.size());
   EXPECT_EQ(100u, Options.LineFilter[2].LineRanges[0].first);
   EXPECT_EQ(1000u, Options.LineFilter[2].LineRanges[0].second);
 }
 
 TEST(ParseConfiguration, ValidConfiguration) {
   llvm::ErrorOr<ClangTidyOptions> Options =
       parseConfiguration(llvm::MemoryBufferRef("Checks: \"-*,misc-*\"\n"
+                                               "SuppressedChecks: \"noisy-*\"\n"
                                                "HeaderFilterRegex: \".*\"\n"
                                                "AnalyzeTemporaryDtors: true\n"
                                                "User: some.user",
                                                "Options"));
   EXPECT_TRUE(!!Options);
   EXPECT_EQ("-*,misc-*", *Options->Checks);
+  EXPECT_EQ("noisy-*", *Options->SuppressedChecks);
   EXPECT_EQ(".*", *Options->HeaderFilterRegex);
   EXPECT_EQ("some.user", *Options->User);
 }
 
 TEST(ParseConfiguration, MergeConfigurations) {
   llvm::ErrorOr<ClangTidyOptions> Options1 =
       parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check1,check2"
+      SuppressedChecks: "noisycheck1,noisycheck2"
       HeaderFilterRegex: "filter1"
       AnalyzeTemporaryDtors: true
       User: user1
       ExtraArgs: ['arg1', 'arg2']
       ExtraArgsBefore: ['arg-before1', 'arg-before2']
       UseColor: false
   )",
                                                "Options1"));
   ASSERT_TRUE(!!Options1);
   llvm::ErrorOr<ClangTidyOptions> Options2 =
       parseConfiguration(llvm::MemoryBufferRef(R"(
       Checks: "check3,check4"
+      SuppressedChecks: "noisycheck3,noisycheck4"
       HeaderFilterRegex: "filter2"
       AnalyzeTemporaryDtors: false
       User: user2
       ExtraArgs: ['arg3', 'arg4']
       ExtraArgsBefore: ['arg-before3', 'arg-before4']
       UseColor: true
   )",
                                                "Options2"));
   ASSERT_TRUE(!!Options2);
   ClangTidyOptions Options = Options1->merge(*Options2, 0);
   EXPECT_EQ("check1,check2,check3,check4", *Options.Checks);
+  EXPECT_EQ("noisycheck1,noisycheck2,noisycheck3,noisycheck4",
+            *Options.SuppressedChecks);
   EXPECT_EQ("filter2", *Options.HeaderFilterRegex);
   EXPECT_EQ("user2", *Options.User);
   ASSERT_TRUE(Options.ExtraArgs.hasValue());
   EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(),
                                               Options.ExtraArgs->end(), ","));
   ASSERT_TRUE(Options.ExtraArgsBefore.hasValue());
   EXPECT_EQ("arg-before1,arg-before2,arg-before3,arg-before4",
             llvm::join(Options.ExtraArgsBefore->begin(),