Allow passing a regex for headers to exclude from clang-tidy

[toddlipcon]

Summary

This patch adds the ability to specify a regex of headers to exclude from clang-tidy diagnostics. This is the inverse of the existing header regex.

In our project we want to do something like include src/.*.h but exclude src/some-thirdparty/.*.h. Given only a positive regex configuration, we would have had to list all directories aside from 'some-thirdparty' such as src/(foo|bar|baz|...)/, which isn't practical or maintainable.

A while back there was a thread http://lists.llvm.org/pipermail/cfe-dev/2015-November/046203.html which suggested using extended regexes which offer negative lookahead assertions to achieve this, but it was rejected due to poor stdlib support. I think an "exclude" regex is also more familiar to users since it shows up commonly in tools like rsync/tar/etc.

(note: I previously posted this as D34415 but was asked to re-post it with cfe-commits as a subscriber. Sorry for the double-post)

[JonasToth]

i added reviewers, since it seems nobody takes care of this check.
remove if this was bad.

[alexfh]

Please regenerate the patch with full context (e.g. as described in llvm.org/docs/Phabricator.html).

[toddlipcon]

Regenerated patch with full context

[alexfh]

I wonder whether anyone uses file patterns that need anything from regular expressions beyond | and .*. If not, globs (as used in -checks=) would be a better solution.

One problem with a header-filter + exclude-header-filter is that it doesn't make it easier to express restrictions similar to "everything under a/ (except for everything under a/b/ (except for everything under a/b/c/))".

[alexfh]

In our project we want to do something like include src/.*.h but exclude src/some-thirdparty/.*.h.

There are at least two other possibilities to handle this use case.

The first one is to extend the way clang-tidy handles per-directory configs. Currently, for each translation unit clang-tidy takes the configuration for the main file of the translation unit and uses the Checks option found in this configuration to filter diagnostics coming from the main file as well as from the headers included by the translation unit. In a better world, it would take the configuration for the header where the diagnostic originates and thus allow a more source-centric way of controlling the set of diagnostics it displays. For example, consider this setup:

a/.clang-tidy: Checks=-*,check1,check2
a/a.cpp: #include a/a.h, #include b/b.h, #include third-party/c.h
a/a.h
b/.clang-tidy: Checks=-*,check2,check3
b/b.h
third-party/.clang-tidy: Checks=-*
third-party/c.h

Let's assume that each of a/a.h, b/b.h, third-party/c.h and a/a.cpp contain code that triggers check1, check2 and check3. Currently, when run on a.cpp without -header-filter, clang-tidy would only output check1 and check2 from a.cpp. -header-filter=.* will result in check1 and check2 diagnostics from all the files.

If we change clang-tidy to apply the most relevant local configuration to the generated diagnostics (and get rid of -header-filter altogether, or set it to .* by default), in the case above it would output check1 and check2 from a/a.cpp and a/a.h, check2 from b/b.h (since we don't even run check3 on the code, and check1 gets filtered out), and no diagnostics from third-party/c.h, since we filter out check1 and check2 according to the local configuration. This seems like a more logical and useful behavior, however, when implementing this we'll have to make sure configuration retrieval doesn't become a bottleneck (FileOptionsProvider already implements some sort of caching, but we'd have to carefully benchmark it on large translation units with tons of diagnostics).

The second way to handle this use case is possible on a different level: one can run clang-tidy over the whole project with -header-filter=.* and then filter the results and use a specialized tool to display them, e.g. https://github.com/Ericsson/codechecker. I'm not sure though whether this suits your needs or is an overkill.

[• lonico]

The second way to handle this use case is possible on a different level: one can run clang-tidy over the whole project with -header-filter=.* and then filter the results and use a specialized tool to display them, e.g. https://github.com/Ericsson/codechecker. I'm not sure though whether this suits your needs or is an overkill.

This approach does not work for us, as our external headers generate a lot of warnings. It's not so much the warnings that are an issue, but generating the notes is taking a lot of time. We implemented this patch in our local installation, and it dramatically reduces the time it takes to run clang-tidy on a "component", where we can focus on the source and header files in a subdirectory tree, and exclude headers from other subdirectories. In the worst case, we're really comparing 1 hour to a few minutes.

Even the first approach is not so interesting, as we would like warnings for another subdirectory tree to be visible in this subdirectory. What we really want is to be able to segregate warnings per component (a subdirectory tree) and don't bother people who import headers from other subdirectory trees with local warnings. So the owner of a subdirectory tree should see all warnings for their tree, but consumers of headers should not be bothered.

[estan]

It would be great to get something like this in.

In our project we're currently using a kludge of overriding the RULE_LAUNCH_COMPILE CMake variable to insert our own shell script as the compiler. The script strips the clang-tidy invocation inserted by CMake if the source path matches any of a set of regexes we have in a .clang-tidy-exclude file.

The original suggested solution with an exclude regex would be sufficient for us, but the source-centric approach described by @alexfh would also work. Just something would be good.

[saimusdev]

Hello,

Any news on accepting this feature?

[srj]

This is marked as "needs revision", but it's not clear to me what the requested changes actually are.

The proposed fix here may not be perfect, but AFAICT, there is simply no good way to exclude headers that are beyond your control at present.

[Hiralo]

We are dependent on this patch to exclude headers in regex while running clang-tidy.
Can we have this patch merged with upcoming GA versions? or
Can someone summarize what is pending in this review or what could be good alternative in v11 clang-tidy?
Thank you in advance.

[MartinG]

More than 3.5 years later and this extremely essential feature hasn't been merged yet?

[Ashimaru]

In my company we are using a lot of standard checks and it becomes time consuming - this patch would be extremely useful to us and non of proposals montioned @alexfh seem to solve the issue.
We would like to select which directories containing headers would be checked and using filtering after checking still has problem of running all checks on file that will later discarded - and we do not like paying for something we do not use ;)

[alexfh]

Repeating my question from an earlier comment: would a header glob list (similar to how the format of the -checks= flag) be enough for the use cases folks have? On the one hand glob list doesn't support all the features of regular expressions, but are they all useful for matching paths? Glob list in clang-tidy currently supports set union (similar to regex |) and <any subsequence> - * (regex .*). If needed, the support can be expanded with ?, character classes, character ranges and/or other features of POSIX globs (https://man7.org/linux/man-pages/man7/glob.7.html). On the flipside, glob list has a cleaner syntax (no need to quote characters common in paths - like .), and allows to easily express exclusion of subsets. It should be a convenient tool to represent a set of files / directories. In comparison to the proposed header-filter + exclude-header-filter glob list makes it possible to naturally express restrictions similar to "everything under a/ (except for everything under a/b/ (except for everything under a/b/c/))" - a/,-a/b/,a/b/c/.

What do folks think?

[aco]

Hi, first of all I want to say that the name "HeaderFilterRegex" is a bit ambiguous, we don't know intuitively if we define what is filtered or what passes.

in my humble opinion alexfh's proposal would be much easier to use than 2 regex.

In D34654#3022728, @alexfh wrote:

would a header glob list (similar to how the format of the -checks= flag) be enough for the use cases folks have?

For me yes it's enough, and will be welcome.

[Ashimaru]

In D34654#3022728, @alexfh wrote:

Repeating my question from an earlier comment: would a header glob list (similar to how the format of the -checks= flag) be enough for the use cases folks have? On the one hand glob list doesn't support all the features of regular expressions, but are they all useful for matching paths? Glob list in clang-tidy currently supports set union (similar to regex |) and <any subsequence> - * (regex .*). If needed, the support can be expanded with ?, character classes, character ranges and/or other features of POSIX globs (https://man7.org/linux/man-pages/man7/glob.7.html). On the flipside, glob list has a cleaner syntax (no need to quote characters common in paths - like .), and allows to easily express exclusion of subsets. It should be a convenient tool to represent a set of files / directories. In comparison to the proposed header-filter + exclude-header-filter glob list makes it possible to naturally express restrictions similar to "everything under a/ (except for everything under a/b/ (except for everything under a/b/c/))" - a/,-a/b/,a/b/c/.

What do folks think?

Yes in my case this would be enough :)

[carlosgalvezp]

I've recently fiddled with the GlobList to enable globbing in NOLINT expressions, so I have it quite fresh and I think it could easily be re-used here. I'd be happy to implement this feature, should I (can I?) continue on this patch or create a brand new one?

[carlosgalvezp]

On the other hand, switching from Regex to Glob will be quite a breaking change - everyone has .* in their config file, which will silently stop to work when switching to Glob and suddenly people won't get their headers linted. What do you think @alexfh ?

[carlosgalvezp]

Also, the new header filter expresion would need to be: HeaderFilter: '*/mydir/*' instead of HeaderFilter: 'mydir'. Perhaps it's clearer since it's more explicit, but it's yet another breaking change.

[carlosgalvezp]

everyone has .* in their config file, which will silently stop to work

Nevermind this. .* treated as a glob will turn into the regex ..* which is equivalent.

[carlosgalvezp]

Here's a patch that uses Globs, let me know how you like it!
https://reviews.llvm.org/D112720

[aminya]

Clang-tidy is very slow if you use it on a medium or large project. Something like this feature, even if it is not perfect, will definitely improve the experience with clang-tidy. The low performance of clang-tidy is one of the biggest frictions for using it.

[justincady]

This feature appears to have strong user support throughout this review, and a lot of people (including myself) seem interested in having it landed.

cc'ing some clang-tidy owners: @LegalizeAdulthood @carlosgalvezp @njames93

Is there anything blocking this from moving forward? Can we work to get it submitted?

clang-tidy/ClangTidyDiagnosticConsumer.h

private:
   void finalizeLastError();
 
   void removeIncompatibleErrors(SmallVectorImpl<ClangTidyError> &Errors) const;
 
   /// \brief Returns the \c HeaderFilter constructed for the options set in the
   /// context.
   llvm::Regex *getHeaderFilter();
 
+  /// \brief Returns the \c ExcludeHeaderFilter constructed for the options set
+  /// in the context.
+  llvm::Regex *getExcludeHeaderFilter();
+
   /// \brief Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
   /// according to the diagnostic \p Location.
   void checkFilters(SourceLocation Location);
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   ClangTidyContext &Context;
   bool RemoveIncompatibleErrors;
   std::unique_ptr<DiagnosticsEngine> Diags;
   SmallVector<ClangTidyError, 8> Errors;
   std::unique_ptr<llvm::Regex> HeaderFilter;
+  std::unique_ptr<llvm::Regex> ExcludeHeaderFilter;
   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

if (!File) {
     LastErrorRelatesToUserCode = true;
     LastErrorPassesLineFilter = true;
     return;
   }
 
   StringRef FileName(File->getName());
   LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
                                Sources.isInMainFile(Location) ||
-                               getHeaderFilter()->match(FileName);
+                               (getHeaderFilter()->match(FileName) &&
+                                !getExcludeHeaderFilter()->match(FileName));
 
   unsigned LineNumber = Sources.getExpansionLineNumber(Location);
   LastErrorPassesLineFilter =
       LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
 }
 
 llvm::Regex *ClangTidyDiagnosticConsumer::getHeaderFilter() {
   if (!HeaderFilter)
     HeaderFilter =
         llvm::make_unique<llvm::Regex>(*Context.getOptions().HeaderFilterRegex);
   return HeaderFilter.get();
 }
 
+llvm::Regex *ClangTidyDiagnosticConsumer::getExcludeHeaderFilter() {
+  if (!ExcludeHeaderFilter)
+    ExcludeHeaderFilter =
+        llvm::make_unique<llvm::Regex>(*Context.getOptions().ExcludeHeaderFilterRegex);
+  return ExcludeHeaderFilter.get();
+}
+
 void ClangTidyDiagnosticConsumer::removeIncompatibleErrors(
     SmallVectorImpl<ClangTidyError> &Errors) const {
   // Each error is modelled as the set of intervals in which it applies
   // replacements. To detect overlapping replacements, we use a sweep line
   // algorithm over these sets of intervals.
   // An event here consists of the opening or closing of an interval. During the
   // process, we maintain a counter with the amount of open intervals. If we
   // find an endpoint of an interval and this counter is different from 0, it

clang-tidy/ClangTidyOptions.h

struct ClangTidyOptions {
 
   /// \brief WarningsAsErrors filter.
   llvm::Optional<std::string> WarningsAsErrors;
 
   /// \brief Output warnings from headers matching this filter. Warnings from
   /// main files will always be displayed.
   llvm::Optional<std::string> HeaderFilterRegex;
 
+  /// \brief Exclude warnings from headers matching this filter, even if they
+  /// match \c HeaderFilterRegex.
+  llvm::Optional<std::string> ExcludeHeaderFilterRegex;
+
   /// \brief Output warnings from system headers matching \c HeaderFilterRegex.
   llvm::Optional<bool> SystemHeaders;
 
   /// \brief Turns on temporary destructor-based analysis.
   llvm::Optional<bool> AnalyzeTemporaryDtors;
 
   /// \brief Format code around applied fixes with clang-format using this
   /// style.

clang-tidy/ClangTidyOptions.cpp

 
 template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
         IO, Options.CheckOptions);
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
+    IO.mapOptional("ExcludeHeaderFilterRegex", Options.ExcludeHeaderFilterRegex);
     IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
     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);
   }
 };
 
 } // namespace yaml
 } // namespace llvm
 
 namespace clang {
 namespace tidy {
 
 ClangTidyOptions ClangTidyOptions::getDefaults() {
   ClangTidyOptions Options;
   Options.Checks = "";
   Options.WarningsAsErrors = "";
   Options.HeaderFilterRegex = "";
+  Options.ExcludeHeaderFilterRegex = "";
   Options.SystemHeaders = false;
   Options.AnalyzeTemporaryDtors = false;
   Options.FormatStyle = "none";
   Options.User = llvm::None;
   for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
                                          E = ClangTidyModuleRegistry::end();
        I != E; ++I)
     Options = Options.mergeWith(I->instantiate()->getModuleOptions());

 
 ClangTidyOptions
 ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
   ClangTidyOptions Result = *this;
 
   mergeCommaSeparatedLists(Result.Checks, Other.Checks);
   mergeCommaSeparatedLists(Result.WarningsAsErrors, Other.WarningsAsErrors);
   overrideValue(Result.HeaderFilterRegex, Other.HeaderFilterRegex);
+  overrideValue(Result.ExcludeHeaderFilterRegex, Other.ExcludeHeaderFilterRegex);
   overrideValue(Result.SystemHeaders, Other.SystemHeaders);
   overrideValue(Result.AnalyzeTemporaryDtors, Other.AnalyzeTemporaryDtors);
   overrideValue(Result.FormatStyle, Other.FormatStyle);
   overrideValue(Result.User, Other.User);
   mergeVectors(Result.ExtraArgs, Other.ExtraArgs);
   mergeVectors(Result.ExtraArgsBefore, Other.ExtraArgsBefore);
 
   for (const auto &KeyValue : Other.CheckOptions)

clang-tidy/tool/ClangTidyMain.cpp

Configuration files:
   option, command-line option takes precedence. The effective
   configuration can be inspected using -dump-config:
 
     $ clang-tidy -dump-config
     ---
     Checks:          '-*,some-check'
     WarningsAsErrors: ''
     HeaderFilterRegex: ''
+    ExcludeHeaderFilterRegex: ''
     AnalyzeTemporaryDtors: false
     FormatStyle:     none
     User:            user
     CheckOptions:
       - key:             some-check.SomeOption
         value:           'some value'
     ...
 

 always displayed.
 Can be used together with -line-filter.
 This option overrides the 'HeaderFilter' option
 in .clang-tidy file, if any.
 )"),
                                          cl::init(""),
                                          cl::cat(ClangTidyCategory));
 
+static cl::opt<std::string>
+    ExcludeHeaderFilter("exclude-header-filter", cl::desc(R"(
+Regular expression matching the names of the
+headers to exclude when outputting diagnostics.
+Diagnostics from the main file of each translation
+unit are always displayed.
+Can be used together with -line-filter.
+This option overrides the 'ExcludeHeaderFilter' option
+in .clang-tidy file, if any.
+)"),
+                                         cl::init(""),
+                                         cl::cat(ClangTidyCategory));
+
 static cl::opt<bool>
     SystemHeaders("system-headers",
                   cl::desc("Display the errors from system headers."),
                   cl::init(false), cl::cat(ClangTidyCategory));
 static cl::opt<std::string> LineFilter("line-filter", cl::desc(R"(
 List of files with line ranges to filter the
 warnings. Can be used together with
 -header-filter. The format of the list is a
if (Stats.ErrorsIgnoredNOLINT) {
       llvm::errs() << Separator << Stats.ErrorsIgnoredNOLINT << " NOLINT";
       Separator = ", ";
     }
     if (Stats.ErrorsIgnoredCheckFilter)
       llvm::errs() << Separator << Stats.ErrorsIgnoredCheckFilter
                    << " with check 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";
+      llvm::errs() << "Use -header-filter=.* -exclude-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,
                              llvm::raw_ostream &OS) {
   // Time is first to allow for sorting by it.
   std::vector<std::pair<llvm::TimeRecord, StringRef>> Timers;
   TimeRecord Total;
if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return nullptr;
   }
 
   ClangTidyOptions DefaultOptions;
   DefaultOptions.Checks = DefaultChecks;
   DefaultOptions.WarningsAsErrors = "";
   DefaultOptions.HeaderFilterRegex = HeaderFilter;
+  DefaultOptions.ExcludeHeaderFilterRegex = ExcludeHeaderFilter;
   DefaultOptions.SystemHeaders = SystemHeaders;
   DefaultOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
   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");
 
   ClangTidyOptions OverrideOptions;
   if (Checks.getNumOccurrences() > 0)
     OverrideOptions.Checks = Checks;
   if (WarningsAsErrors.getNumOccurrences() > 0)
     OverrideOptions.WarningsAsErrors = WarningsAsErrors;
   if (HeaderFilter.getNumOccurrences() > 0)
     OverrideOptions.HeaderFilterRegex = HeaderFilter;
+  if (ExcludeHeaderFilter.getNumOccurrences() > 0)
+    OverrideOptions.ExcludeHeaderFilterRegex = ExcludeHeaderFilter;
   if (SystemHeaders.getNumOccurrences() > 0)
     OverrideOptions.SystemHeaders = SystemHeaders;
   if (AnalyzeTemporaryDtors.getNumOccurrences() > 0)
     OverrideOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
   if (FormatStyle.getNumOccurrences() > 0)
     OverrideOptions.FormatStyle = FormatStyle;
 
   if (!Config.empty()) {

docs/clang-tidy/index.rst

Configuration files:
     option, command-line option takes precedence. The effective
     configuration can be inspected using -dump-config:
 
       $ clang-tidy -dump-config
       ---
       Checks:          '-*,some-check'
       WarningsAsErrors: ''
       HeaderFilterRegex: ''
+      ExcludeHeaderFilterRegex: ''
       AnalyzeTemporaryDtors: false
       FormatStyle:     none
       User:            user
       CheckOptions:
         - key:             some-check.SomeOption
           value:           'some value'
       ...
 

test/clang-tidy/file-filter.cpp

 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK-QUIET %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2 %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK2-QUIET %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header2\.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3 %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='header2\.h' -quiet %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK3-QUIET %s
 // FIXME: "-I %S/Inputs/file-filter/system/.." must be redundant.
 //       On Win32, file-filter/system\system-header1.h precedes
 //       file-filter\header*.h due to code order between '/' and '\\'.
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4 %s
 // RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -system-headers -quiet %s -- -I %S/Inputs/file-filter/system/.. -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK4-QUIET %s
+// RUN: clang-tidy -checks='-*,google-explicit-constructor' -header-filter='.*' -exclude-header-filter='header1\.h' %s -- -I %S/Inputs/file-filter -isystem %S/Inputs/file-filter/system 2>&1 | FileCheck --check-prefix=CHECK5 %s
 
 #include "header1.h"
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK2-QUIET: header1.h:1:12: warning: single-argument constructors must be marked explicit
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:
 // CHECK4: header1.h:1:12: warning: single-argument constructors
 // CHECK4-QUIET: header1.h:1:12: warning: single-argument constructors
+// CHECK5-NOT: warning:
 
 #include "header2.h"
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2: header2.h:1:12: warning: single-argument constructors
 // CHECK2-QUIET: header2.h:1:12: warning: single-argument constructors
 // CHECK3: header2.h:1:12: warning: single-argument constructors
 // CHECK3-QUIET: header2.h:1:12: warning: single-argument constructors
 // CHECK4: header2.h:1:12: warning: single-argument constructors
 // CHECK4-QUIET: header2.h:1:12: warning: single-argument constructors
+// CHECK5: header2.h:1:12: warning: single-argument constructors
 
 #include <system-header.h>
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2-NOT: warning:
 // CHECK2-QUIET-NOT: warning:
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:
 // CHECK4: system-header.h:1:12: warning: single-argument constructors
 // CHECK4-QUIET: system-header.h:1:12: warning: single-argument constructors
+// CHECK5-NOT: warning:
 
 class A { A(int); };
 // CHECK: :[[@LINE-1]]:11: warning: single-argument constructors
 // CHECK-QUIET: :[[@LINE-2]]:11: warning: single-argument constructors
 // CHECK2: :[[@LINE-3]]:11: warning: single-argument constructors
 // CHECK2-QUIET: :[[@LINE-4]]:11: warning: single-argument constructors
 // CHECK3: :[[@LINE-5]]:11: warning: single-argument constructors
 // CHECK3-QUIET: :[[@LINE-6]]:11: warning: single-argument constructors
 // CHECK4: :[[@LINE-7]]:11: warning: single-argument constructors
 // CHECK4-QUIET: :[[@LINE-8]]:11: warning: single-argument constructors
+// CHECK5: :[[@LINE-9]]:11: warning: single-argument constructors
 
 // CHECK-NOT: warning:
 // CHECK-QUIET-NOT: warning:
 // CHECK2-NOT: warning:
 // CHECK2-QUIET-NOT: warning:
 // CHECK3-NOT: warning:
 // CHECK3-QUIET-NOT: warning:
 // CHECK4-NOT: warning:
 // CHECK4-QUIET-NOT: warning:
+// CHECK5-NOT: warning:
 
 // CHECK: Suppressed 3 warnings (3 in non-user code)
-// CHECK: Use -header-filter=.* to display errors from all non-system headers.
+// CHECK: Use -header-filter=.* -exclude-header-filter='' to display errors from all non-system headers.
 // CHECK-QUIET-NOT: Suppressed
 // CHECK2: Suppressed 1 warnings (1 in non-user code)
 // CHECK2: Use -header-filter=.* {{.*}}
 // CHECK2-QUIET-NOT: Suppressed
 // CHECK3: Suppressed 2 warnings (2 in non-user code)
 // CHECK3: Use -header-filter=.* {{.*}}
 // CHECK3-QUIET-NOT: Suppressed
 // CHECK4-NOT: Suppressed {{.*}} warnings
 // CHECK4-NOT: Use -header-filter=.* {{.*}}
 // CHECK4-QUIET-NOT: Suppressed
+// CHECK5: Suppressed 2 warnings (2 in non-user code)
+// CHECK5: Use -header-filter=.* {{.*}}